精华内容
下载资源
问答
  • c++类与对象
    千次阅读
    2020-06-04 11:16:07

    类与对象-定义一个学生类

    需要string类型
    一定要注意导入string


    #include<iostream>
    #include<string>
    using namespace std;
    
    class Stutent
    {
    public :
    	string m_Name;
    	int m_Id;
    	void setName(string name)
    	{
    		m_Name = name;
    	}
    	void setId(int id)
    	{
    		m_Id = id;
    	}
    	void show()
    	{
    		cout << "名字:" << m_Name << endl;
    		cout << "号:" << m_Id << endl;
    	}
    };
    int main()
    {
    	Stutent s;
    	s.setId(10);
    	s.setName("王");
    	s.show();
    }
    
    更多相关内容
  • C++类与对象_简单练习题

    千次阅读 多人点赞 2019-03-25 17:19:33
    ## C++ 类与对象练习题: **在主函数中生成一个时钟对象,并为其设置时间和显示时间** 这是一道入门题,主要是为了熟悉类与对象,以及成员函数,数据成员的实现; 在此先强调几点C的区别或者说创建类与对象的...

    ## C++ 类与对象练习题:

    **在主函数中生成一个时钟对象,并为其设置时间和显示时间**

     

    这是一道入门题,主要是为了熟悉类与对象,以及成员函数,数据成员的实现;

     

    在此先强调几点与C的区别或者说创建类与对象的注意点:

     

    1.C++的类习惯在主函数外定义,在主函数内部用类声明对象,类似C中的结构体,(当然结构体也可以在内部定义,只是习惯外部);

    2.c++的类内函数声明,必须加上返回值类型,否则它默认为int 型,在vs中也会报错;

    3.而且在函数声明时,在返回值与函数名之间必须加上 "类名::",但数据成员是可以直接使用,而不用加前面的限制;

    5.在主函数中要先用类来声明对象,然后用对象才能调用函数,调用形式为

    对象名.函数名;

     

    下面附上代码:

    #include<iostream>
    using namespace std;
    class clock {
    public:
    void 	settime(int , int , int );
    void 	showtime();
    private:
    	int hour;
    	int mintue;
    	int second;
    
    };
    void clock:: settime(int nhour, int nmin, int nsec)
    {
    	hour = nhour;
    	mintue = nmin;
    	second = nsec;
    }
      void clock::showtime()
    {
    	cout << hour<<":"<< mintue <<":" << second << endl;
    }
    int main()
    {
    
    	clock myClock;
    	myClock.settime(16, 30, 01);
    	myClock.showtime();
    	return 0;
    }
    输出结果
     
    展开全文
  • C++ 类与对象

    千次阅读 2012-09-06 13:58:30
    C++类与对象(1)  下个阶段,我将讲解C++中面向对象的部分,也是C++对C语言改进的最重要的部分。以前C++也被叫做是"带的C"。今天主要讲的构成,成员函数以及对象的定义和使用。  1.其实这一节,...

    C++之类与对象(1)

      下个阶段,我将讲解C++中面向对象的部分,也是C++对C语言改进的最重要的部分。以前C++也被叫做是"带类的C"。今天主要讲类的构成,成员函数以及对象的定义和使用。

      1.其实这一节,对于用C#开发的人来说,简直就是驾轻就熟啊。C++类的构成,我想从C的结构体开始说起。C中的结构体我想大家在熟悉不过了。

    复制代码
     1 #include "stdafx.h"
    2 #include <iostream>
    3
    4 usingnamespace std;
    5
    6 struct Kid
    7 {
    8 int age;
    9 char*name;
    10 char*sex;
    11 };
    12
    13 int main()
    14 {
    15 Kid kid1;
    16 kid1.age=10;
    17 kid1.name="rookie_j";
    18 kid1.sex="";
    19 cout<<"姓名:"<<kid1.name<<endl<<"年龄:"<<kid1.age<<endl<<"性别:"<<kid1.sex<<endl;
    20 return0;
    21 }
    复制代码

      但是C中的结构体存在缺点:1.main函数中的任意赋值语句都可以访问结构体中的成员,但在现实生活中并不是什么数据都可以被随意访问的,因此C语言中的结构体的数据是不安全的;2.结构体中的数据和对该数据的操作是分离的,并不是一个被封装起来的整体,因此使程序难以重用,影响了软件生产效率;于是C++中引入了类的概念。

      C++中类的一般格式为:

    class Kid

    {

      private:

        int age;    //私有成员

        char *name;

        char *sex;

      public:      //公有成员

        void setKid(int age,char *name,char *sex);

        void showKid();

    };

    C++中规定如果没有对类的成员加私有private,保护protected,或公有public,则默认为私有的。而对于C++的结构体来说,成员可以是私有的,保护的或公有的,但默认为公有的;还有要注意的是不能在类的声明中给数据成员赋值,比如:

    class Kid

    {

      private :

        int age=10;

        char *name="rookie_j";

        char *sex="男";

    };

      一般情况下,一个类的数据成员应该声明为私有的,成员函数声明为共有的。这样,内部的数据隐藏在类中,在类的外部无法访问直接访问,使数据得到有效的保护。而公有的成员函数就成为一种与类外部沟通的接口。

      2.C++中的成员函数有两种,一种为普通的成员函数:

    复制代码
     1 class Kid
    2 {
    3 private:
    4 int age;
    5 char*name;
    6 char*sex;
    7 public:
    8 void setKid(int age,char*name,char*sex);
    9 void showKid();
    10
    11 };
    12
    13
    14 void Kid::setKid(int age,char*name,char*sex)
    15 {
    16 Kid::age=age;
    17 Kid::name=name;
    18 Kid::sex=sex;
    19 }
    20
    21 void Kid::showKid()
    22 {
    23 cout<<"姓名:"<<name<<endl<<"年龄:"<<age<<endl<<"性别:"<<sex<<endl;
    24 }
    复制代码

    要注意几点:1.类名和函数名之间应加上作用域运算符“::”,用于声明这个成员函数是属于哪一个类的,如果在函数名前没有类名,或既无类名又无作用域运算符“::”,比如:::showKid()或showKid(),那么这个函数不属于任何类,不是成员函数,而是普通函数;2.在类的声明中,成员函数原型的参数表中可以不说明参数的名字,而只说明它的类型,但在类外定义时必须既要说明参数类型又要说明参数名;

      另外一种就是内联成员函数,它又分显式声明和隐式声明:

    隐式声明:

    复制代码
     1 class Kid
    2 {
    3 private:
    4 int age;
    5 char*name;
    6 char*sex;
    7 public:
    8 void setKid(int age,char*name,char*sex)
    9 {
    10 Kid::age=age;
    11 Kid::name=name;
    12 Kid::sex=sex;
    13 }
    14 void showKid()
    15 {
    16 cout<<"姓名:"<<name<<endl<<"年龄:"<<age<<endl<<"性别:"<<sex<<endl;
    17 }
    18
    19 };
    复制代码

     因为这种定义的内联成员函数没有使用关键字inline进行声明,因此叫隐式定义;

    显式声明:

    复制代码
     1 class Kid
    2 {
    3 private:
    4 int age;
    5 char*name;
    6 char*sex;
    7 public:
    8 inline void setKid(int age,char*name,char*sex);
    9 inline void showKid();
    10 };
    11
    12
    13 inline void Kid::setKid(int age,char*name,char*sex)
    14 {
    15 Kid::age=age;
    16 Kid::name=name;
    17 Kid::sex=sex;
    18 }
    19
    20 inline void Kid::showKid()
    21 {
    22 cout<<"姓名:"<<name<<endl<<"年龄:"<<age<<endl<<"性别:"<<sex<<endl;
    23 }
    复制代码

    内联函数的调用就是代码的扩展,而不是一般函数的调用的操作;但要注意的是使用inline定义的内联函数必须将类的声明和内联成员函数的定义都放在同一个文件中,否则编译时无法进行代码的置换

      3.在C++中,类与对象的关系,可以用数据类型int和整形变量i之间的关系来类比。int类型和类类型代表一种抽象的概念,而整形变量和类的对象代表具体的东西。C++把类的变量称为类的对象,对象也被称为类的实例;类的对象可以是:

     

    复制代码
     1 class Kid
    2 {
    3 private:
    4 int age;
    5 char*name;
    6 char*sex;
    7 public:
    8 inline void setKid(int age,char*name,char*sex);
    9 inline void showKid();
    10 }kid1,kid2;
    复制代码

     

    也可以是声明了类后,使用时在定义对象:Kid kid1,kid2;(声明一个类后,它并不接受和存储具体的值,只作为生成具体对象的一种“样板”,只有定义了对象后,系统才为对象分配存储空间,以存放对象中的成员);

      对对象中的成员的访问可以是:1.对象名.数据成员名/对象名.成员函数名(参数),比如kid1.setKid(10,"rookie_j","男");2.指针访问对象中成员,比如:class Kid{public: int age;}; Kid kid,*ptr; ptr=&kid;cout<<ptr->age//cout<<(*ptr).age;3.还记得上节所讲到的引用(reference)么,还可以通过引用来访问对象中的成员:class Kid{public: int age;}; Kid kid;Kid &ptr=kid; cout<<ptr.age//cout<<kid.age;

      4.最后我们还是一样,用一个实例来总结一下今天所讲的内容(开发工具:vs2010):

    复制代码
     1 #include "stdafx.h"
    2 #include <iostream>
    3
    4 usingnamespace std;
    5
    6 struct struct_Kid //结构体
    7 {
    8 int age; //默认公有
    9 char*name;
    10 char*sex;
    11 }kid1;
    12
    13 class Kid
    14 {
    15 int age; //默认私有
    16
    17 private: //私有
    18 char*name;
    19 char*sex;
    20
    21 public: //公有
    22 inline void setKid(int age,char*name,char*sex);//显示内联
    23 /*{
    24 Kid::age=age;
    25 Kid::name=name;
    26 Kid::sex=sex;
    27 }*/
    28 void showKid()//隐式内联
    29 {
    30 cout<<"类:"<<endl<<"姓名:"<<name<<endl<<"年龄:"<<age<<endl<<"性别:"<<sex<<endl;
    31 }
    32
    33 }kid2;//直接定义对象
    34
    35
    36 inline void Kid::setKid(int age,char*name,char*sex)
    37 {
    38 Kid::age=age;
    39 Kid::name=name;
    40 Kid::sex=sex;
    41 }
    42
    43 int main()
    44 {
    45 //结构体
    46 kid1.age=10;
    47 kid1.name="rookie_j";
    48 kid1.sex="";
    49 cout<<"结构体:"<<endl<<"姓名:"<<kid1.name<<endl<<"年龄:"<<kid1.age<<endl<<"性别:"<<kid1.sex<<endl;
    50
    51 cout<<"--------------------"<<endl;
    52
    53 //
    54 Kid kid3,*ptr;
    55 Kid &kid4=kid3;
    56 ptr=&kid2;
    57
    58 kid2.setKid(0,"rookie_y","");
    59 kid2.showKid();
    60
    61 cout<<"--------------------"<<endl;
    62
    63 //指针调用成员函数
    64 (*ptr).setKid(20,"rookie_y","");//或ptr->setKid(20,"rookie_z","女");
    65 kid2.showKid();
    66
    67 cout<<"--------------------"<<endl;
    68
    69 //对象名调用成员函数
    70 kid3.setKid(10,"rookie_x","");
    71 kid3.showKid();
    72
    73 cout<<"--------------------"<<endl;
    74
    75 //引用调用成员函数
    76 kid4.setKid(30,"rookie_x","");
    77 kid3.showKid();
    78
    79 return0;
    80 }
    复制代码

    结果:


     


    C++之类与对象(2)

      接着上一节,今天讲C++中类的构造函数与析构函数,对象的赋值与复制.

      1.用过C#语言的人,都知道构造函数是一种特殊的成员函数,它主要用于对对象分配空间,进行初始化。构造函数的名字必须与类名相同。可以有任何类型的参数,但不返回任何值,是在建立对象时自动执行的。和上一节一样,还是用Kid类来说明。

    复制代码
     1 class Kid
    2 {
    3 private:
    4 int age;
    5 char*name;
    6 char*sex;
    7 public:
    8 Kid(int age,char*name,char*sex);
    9 void showKid();
    10 };
    11
    12 Kid::Kid(int age,char*name,char*sex)
    13 {
    14 Kid::age=age;
    15 Kid::name=name;
    16 Kid::sex=sex;
    17 }
    18
    19 void Kid::showKid()
    20 {
    21 cout<<"姓名:"<<name<<endl<<"年龄:"<<age<<endl<<"性别:"<<sex<<endl;
    22 }
    复制代码

      接下来,建立对象并初始化:Kid kid(10,"rookie_j","男");另外一种使用new运算符动态建立对象:Kid *ptr=new Kid(10,"rookie_j","男");通过指针变量ptr来访问:ptr->showKid();当我们用new建立对象时,当不再使用它时,要用delete运算符释放它:delete ptr;和不同成员函数一样,如果构造函数定义在类体内部,则作为内联函数处理;

      在声明类时,对数据成员的初始化一般在构造函数中用赋值语句进行,但C++还提供了另外一种初始化数据成员的方法——用成员初始化表来实现对数据成员的初始化。它的一般形式为:类名::构造函数名([参数表]):[(成员初始化表)];成员初始化表的形式为:成员名1(初始值1),成员名2(初始值2),成员名2(初始值2);比如:

    Kid::Kid(int age,char *name,char *sex):age(age),name(name),sex(sex){};

      接下来讲一下析构函数:在我第一次在C++里看到这个名词时,感觉这个知识点很深奥,结果看了以后,其实很简单。它的作用和构造函数刚好相反,用于撤销对象,如:释放分配给对象的内存空间。析构函数和构造函数名相同,但在其前面要加~符号,析构函数没有参数,也没有返回值,且不能重载,因此一个类中只有一个析构函数。以下三种情况,当对象的生命周期结束时,析构函数会被自动调用:(1)定义了全局对象,则在程序流程离开其作用域(如:main函数结束或调用Exit)时,调用该全局对象的析构函数;(2)对象被定义在函数体里,则当这个函数执行完后,该对象释放,析构函数被自动调用;(3)若一个对象使用new运算符动态创建的,在使用delete运算符释放它时,会自动调用析构函数;

    View Code

    结果:

      如果没有给类定义构造函数,则编译系统自动地生成一个默认的构造函数,比如在Kid类中编译系统会为其产生一个Kid::Kid(){};构造函数,这个默认的构造函数只能给对象开辟存储空间,不能给数据成员赋值,这时数据成员的初值就是随机数。对没有定义构造函数的类,其公有数据成员可以用初始化值表进行初始化,如:

    复制代码
     1 class Kid
    2 {
    3 public:
    4 int age;
    5 char*name;
    6 char*sex;
    7 };
    8
    9 int main()
    10 {
    11
    12 Kid kid={10,"Rookie_j",""};
    13 cout<<"姓名:"<<kid.name<<endl<<"年龄:"<<kid.age<<endl<<"性别:"<<kid.sex<<endl;
    14
    15 return0;
    16 }
    复制代码

    但只要一个类定义了构造函数,系统将不再给它提供默认构造函数;另外还有默认的析构函数(Kid::~Kid(){})一般来说默认的析构函数就能满足要求,但对一些需要做一些内部处理的则应该显式定义析构函数。带默认参数的构造函数和之前所说的带参数的成员函数是一样的,对于构造函数的重载,在这里我就不多说了,只想强调一点,如果是无参的构造函数创建对象,应该使用"类名 对象名"的形式,而不是"类名 对象名()";

      2.对象的赋值其实和变量的赋值差不多,也是用赋值运算符=进行的,只不过进行赋值的两个对象的类型必须相同,对象之间的赋值只是数据成员的赋值,而不对成员函数赋值;

     

    View Code

     

    结果:

      拷贝构造函数是一种特殊的构造函数,其形参是类对象的引用。它主要用于在建立一个新的对象时,使用已经存在的对象去初始化这个新对象。拷贝构造函数也是构造函数,所以函数名必须与类名相同,参数只有一个就是同类对象的引用,每个类必须要有一个拷贝构造函数。如果程序员自己不定义拷贝构造函数,系统会自动产生一个默认拷贝构造函数。调用拷贝构造函数的形式有代入法:类名 对象2(对象1)和赋值法:类名 对象2=对象1;

    View Code

    结果:

     

      同样的默认的拷贝构造函数:复制出与源对象的数据成员的值一样的新对象。调用拷贝构造函数的3种情况:(1)Kid kid2(kid1)或Kid kid2=kid1;(2)函数的形参是类的对象:fun(Kid kid){kid.showKid();}; int main(){Kid kid(10,"Rookie_j","男");fun(kid);return 0;};(3)函数返回值为类的对象:Kid fun(){Kid kid(10,"Rookie_j","男"); return kid;} int main(){ Kid kid; kid=fun();kid.showKid();return 0;};

      3.最后还是一样用一个实例来总结一下今天所说的内容(开发工具:vs2010):

    View Code

    结果:

    但在运行的时候,发现一个问题如果把delete ptr; 这句的注释去掉,结果汽车的情况就显示不出来了;

    结果:


    C++之类与对象(3)

      在上篇的最后的实例程序代码中,我所写的成员函数中的参数变量名和数据成员名一样,为了编译时不发生错误,我在数据成员的前面加上"类名::"以区分。其实还有另外一种方法可以来加以区分,那就是C++中的自引用指针this。今天就讲一下C++中的this以及string类。可能代码不会很多,但突出原理;

      1.this这个关键字其实对于我来说并不陌生,在C#中就常用到。但今天我想说说为什么要有this,this起到什么作用?话还是要从类和对象说起,大家都知道定义一个对象,系统要给该对象分配存储空间,如果该类包含了数据成员和成员函数,就要分别给数据和函数的代码分配存储空间。按照正常额思路,如果类定义了2个对象,那么就应该分别给这2个对象的数据和函数分配空间。但事实并非如此,C++的编译系统只用了一段空间来存放在各个共同的函数代码段,在调用各个对象的成员函数时,都与调用这个公共的函数代码。因此,每个对象的存储空间都只是该对象数据成员所占用的存储空间,而不包括成员函数代码所占有的空间,函数代码是存储在对象空间之外的。但是问题就出来了,既然所有对象所调用的成员函数代码只是单独一封,那么成员函数是怎么知道当前调用自己的是哪一个对象呢?

      这时就诞生了this这个玩意,它是一个自引用的指针。每当创建一个对象时,系统就把this指针初始化为指向该对象,即this指针的值为当前调用成员函数的对象的起始地址。每当调用一个成员函数时,系统就把this指针作为一个隐含的参数传给该函数。不同的对象调用同一个成员函数时,C++编译器将根据成员函数的this指针所指向的对象来确定应该调用哪一个对象的数据成员。通过下面一个简单实例就可说明。

    复制代码
     1 #include "stdafx.h"
    2 #include <iostream>
    3 #include <string>
    4
    5
    6 class Num
    7 {
    8 private:
    9 int a;
    10 std::string objectName;
    11 public:
    12 Num(std::string objectName,int a);
    13 void showNum();
    14 };
    15
    16 Num::Num(std::string objectName,int a)
    17 {
    18 this->objectName=objectName;
    19 this->a=a;
    20 }
    21
    22 void Num::showNum()
    23 {
    24 std::cout<<this->objectName<<":this="<<this<<" a="<<this->a<<std::endl;
    25 }
    26
    27
    28 int main()
    29 {
    30 Num num1("num1",1);
    31 Num num2("num2",2);
    32 Num num3("num3",3);
    33
    34 num1.showNum();
    35 num2.showNum();
    36 num3.showNum();
    37
    38 return0;
    39 }
    复制代码

    结果:

      2.在前几篇的代码中,我都是用Char *字符串指针来定义字符变量,还有就是在上一篇中的Kid类中的构造函数,用到过字符数组。并用字符复制函数strcpy,从中出现了问题,后来在博友的帮助下解决了。strcpy、strcat(字符串连接)和字符串长度(strlen),都是C中标准库函数的字符串操作。C++保留了这种格式,但是这种方法使用起来不太方便,另外数据与处理数据的函数相分离也不符合面向对象的思想。于是C++的标准库中,就出现了字符串类string。在使用string类型时,要在头文件中加入#include<string>;string的用法我在上述的例子中也有用到。在比如:string str("Hello C++")或string str="Hello C++";同时,也可以在表达式中把string对象和以'\0'结束符混在一起使用。

      3.最后来列个表说明一下string中常用的运算符:


     转载地址: http://www.cnblogs.com/CaiNiaoZJ/archive/2011/07/17/2108445.html



    展开全文
  • C++类对象详解

    千次阅读 多人点赞 2019-03-25 18:00:30
    类与对象上篇: 主要内容: 1.对象的区别。 2.的定义。 3.的访问限定符和封装 4.的作用域 5.的实例化(用类型创建对象) 6.计算类对象的大小 7.this指针 C语言是面向过程的,关注的是过程,分析出求解...

    类与对象上篇:

    主要内容:
    1.类和对象的区别。
    2.类的定义。
    3.类的访问限定符和封装
    4.类的作用域
    5.类的实例化(用类类型创建对象)
    6.计算类对象的大小
    7.this指针

    C语言是面向过程的,关注的是过程,分析出求解问题的步骤,通过函数调用逐步解决问题。
    C++是基于面向对象的,关注的是对象,将一件事情拆分成不同的对象,靠对象之间的交互完成。

    1.类和对象的区别:
    类是抽象的,不占用内存。
    对象是具体的,占用内存。
    类是对象的抽象,而对象是类的具体事项;
    比如说:类是蔬菜,那么对象就是青菜等等。

    2.类的定义:

    class className
    {
    	 // 类体:由成员函数和成员变量组成
     
    }; 	// 一定要注意后面的分号
    

    class为定义类的关键字ClassName类的名字{}中为类的主体注意类定义结束时后面分号
    类中的元素称为类的成员:类中的数据称为类的属性或者成员变量; 类中的函数称为类的方法或者成员函数。

    类的两种定义方式:

    1. 声明和定义全部放在类体中,需要注意:成员函数如果在类中定义。
    2. 声明放在.h文件中,类的定义放在.cpp文件中。

    一般情况下,更希望大家采用第二种方式。

    3.类的访问限定符及封装
    类的访问限定符:
    public
    protected
    private
    说明:

    1. public修饰的成员在类外可以直接被访问。
    2. protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的).
    3. 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止。
    4. class的默认访问权限为private,struct为public(因为struct要兼容C)。

    经常会有面试题这样问大家:
    问题:C++中struct和class的区别是什么?

    **答:**C++需要兼容C语言,所以C++中struct可以当成结构体去使用。另外C++中struct还可以用来定义类。和class是定义类是一样的,区别是struct的成员默认访问方式是public,class是struct的成员默认访问方式是private。

    封装:
    面向对象的三大特性:封装、继承、多态。

    封装:将数据和操作数据的方法进行有机结合,隐藏对象的属性和实现细节,仅对外公开接口来和对象进行交互。

    封装的本质就是一种管理:比如博物馆的文物,我们如何管理呢?首先是键一座房子把文物给封装起来。然后我们开放了售票通道。可以买票突破封装在和合理的监管机制下去参观。类也是一样,我们使用类数据和方法都封装到一下。不想给别人看到的,我们使用protected/private把成员封装起来。开放一些共有的成员函数对成员合理的访问。所以封装本质是一种管理
    C++实现封装的方式:用类将对象的属性与方法结合在一块,让对象更加完善,通过访问权限选择性的将其接口提供给外部的用户使用。

    4.类的作用域

    1. 每个类都定义了自己的作用域,类的成员(成员函数/成员变量)都在类的这个作用域内,成员函数内可任意访问成员变量和其它成员函数。
    2. 对象可以通过 . 直接访问公有成员,指向对象的指针通过 -> 也可以直接访问对象的公有成员。
    3. 在类体外定义成员,需要使用 :: 作用域解析符指明成员属于哪个类域。
    class Person
    {
    public:
    	 void PrintPersonInfo();
    private:
    	char _name[20];
    	 char _gender[3];
    	 int _age;
    };
    // 这里需要指定PrintPersonInfo是属于Person这个类域
    void Person::PrintPersonInfo()
    {
    	 cout<<_name<<" "_gender<<" "<<_age<<endl;
    }
    

    5.类的实例化
    用类类型创建对象的过程称为类的实例化。

    class Person
    {
    public:
    	 void PrintPersonInfo();
    private:
    	 char _name[20];
    	 char _gender[3];
    	 int _age;
    };
    void Test()
    {
    	Person man;
    	man._name = "Peter";
    	man._age = 10;
    	man._sex = "男";
    	man.PrintPersonInfo();
    
    }
    

    6.计算类对象的大小

    看代码:

    class A
    {
    public:
    	void TestFunc()
    	{}
    
    
    	int _a;
    	char _b;
    };
    
    class B
    {
    public:
    	void TestFunc()
    	{}
    };
    
    // 空类
    class C
    {};
    
    
    // 类大小的计算方式:类成员变量加起来 + 内存对齐
    // 求结构体大小一模一样
    
    // 空类和没有类成员变量的类的大小为一个字节
    int main()
    {
    	cout << sizeof(A) << endl;
    	cout << sizeof(B) << endl;
    	cout << sizeof(C) << endl;
    	system("pause");
    	return 0;
    }
    

    运行结果
    在这里插入图片描述
    结论:一个类的大小,实际就是该类中”成员变量”之和,当然也要进行内存对齐,注意空类(包括没有成员变量的类)的大小,空类比较特殊,编译器给了空类一个字节来唯一标识这个类。(比如如果现在给了C1,C2,C3三个空类,如果不给内存,那就无法区分这3个类)

    7 this指针

    先定义一个日期类

    class Date
    { 
    public :
     void Display ()
     {
    	 cout <<_year<< "-" <<_month << "-"<< _day <<endl;
     }
     
     void SetDate(int year , int month , int day)
     {
    	 _year = year;
    	 _month = month;
    	 _day = day;
     }
    private :
    	 int _year ; // 年
     	int _month ; // 月
    	 int _day ; // 日
    };
    int main()
    {
    	 Date d1, d2;
    	 d1.SetDate(2018,5,1);
    	 d2.SetDate(2018,7,1);
    	d1.Display();
     	d2.Display();
     	return 0;
    }
    

    对于上述类,有这样的一个问题
    Date类中有SetDate与Display两个成员函数,函数体中没有关于不同对象的区分,那当s1调用SetDate函数时,该函数是如何知道应该设置s1对象,而不是设置s2对象呢?
    C++中通过引入this指针解决该问题,即:C++编译器给每个“成员函数“增加了一个隐藏的指针参数,让该指针指向当前对象(函数运行时调用该函数的对象),在函数体中所有成员变量的操作,都是通过该指针去访问。只不过所有的操作对用户是透明的,即用户不需要来传递,编译器自动

    编译器自动操作完成后:

    class Date
    { 
    public :
     void Display (Date* this)
     {
    	 cout <<this->_year<< "-" <<this->_month << "-"<< this->_day <<endl;
     }
     
     void SetDate(Date* this,int year , int month , int day)
     {
    	this-> _year = year;
    	this-> _month = month;
    	this-> _day = day;
     }
    private :
    	 int _year ; // 年
     	int _month ; // 月
    	 int _day ; // 日
    };
    int main()
    {
    	 Date d1, d2;
    	 d1.SetDate(2018,5,1);
    	 d2.SetDate(2018,7,1);
    	d1.Display();
     	d2.Display();
     	return 0;
    }
    
    

    this指针的特性:

    1. this指针的类型:类类型* const
    2. 只能在“成员函数”的内部使用
    3. this指针本质上其实是一个成员函数的形参,是对象调用成员函数时,将对象地址作为实参传递给this形参。所以对象中不存储this指针。
    4. this指针是成员函数第一个隐含的指针形参,一般情况由编译器通过ecx寄存器自动传递,不需要用户传递

    关于this指针的一个面试题:

    问题:下面程序能通过编译吗?如果崩溃,会在哪里奔溃?

    class A
    { 
    public:
     void PrintA() 
     {
     	cout<<_a<<endl;
     }
     
     void Show()
     {
    	 cout<<"Show()"<<endl;
     }
    private:
     	int _a;
    };
    int main()
    {
    	 A* p = nullptr;
    	 p->PrintA(); 
    	 p->Show();
    }
    

    答案:能够编译通过,但会崩溃。因为p指向空,然后在运行类中的成员函数时,会通过p找到this指针。此时就会越界访问


    未完待续!!!

    展开全文
  • C++类与对象的关系

    千次阅读 2017-03-26 17:02:42
    C++是一门面向对象的编程语言,理解C++,首先要理解(Class)和对象(Object)这两个概念。 C++中的(Class)可以看做C语言中结构体(Struct)的升级版。结构体是一种构造类型,可以包含若干成员变量,每个...
  • 设计一个立方体Box,它能计算并输出立方体的体积和表面积。其中Box包含三个私有数据成员 a(立方体边长)volume(体积)和 area(表面积),另有两个构造函数以及getvolume()(计算体积)、getarea()(计算表面积)和 ...
  • C++类对象的创建释放过程

    千次阅读 2019-08-16 16:58:18
    C++类对象的创建释放过程类对象的创建过程类对象的释放过程析构函数缺省析构函数 类对象的创建过程 1、分配所需要的空间,无论是栈还是堆。 2、传递实参调用构造函数,完成如下任务: 1、根据继承表依次调用父类...
  • 定义C++类对象的方法

    千次阅读 2021-06-08 09:56:45
    定义C++类对象的方法 我们学习了的定义,C语言的struct结构体类型定义差不多。那么,C语言可以使用struct结构体类型来定义对象,那么,C++同样可以使用来定义对象C++使用来定义对象也可以有几种方法...
  • C++类对象的赋值操作

    千次阅读 2021-06-11 10:37:20
    那么,如果是C++类对象的赋值,会是怎么样的操作? 类对象之间的赋值也可以通过赋值运算符“=”进行。对象赋值的一般形式为: 对象名1 = 对象名2; 注意,对象名1和对象名2必须属于同一个。此时,对象名2的成员...
  • C++类对象的使用之对象指针

    万次阅读 多人点赞 2019-07-04 21:38:07
    C++中,可以说明指向的数据成员和成员函数的指针。 对象指针遵循一般变量指针的各种规则:类名 *对象指针名; 对象指针名*成员名; 对象指针在使用之前,也一定要先进行初始化,让它指向一个已经声明过的对象,...
  • C++类对象指针的区别

    万次阅读 多人点赞 2019-04-17 20:57:28
    一篇转载率较高的帖子:C++ 类对象和 指针的区别 大佬都不贴结果。。。。所以这里我给出代码和结果: #include<iostream> using namespace std; class Test{ public: int a; Test(){ a = 1; } }; ...
  • 2013级,C++程序设计课件。第8章 对象,内容 8.1 面向对象程序设计方法概述 8.2 的声明和对象的定义 8.3 的成员函数 8.4 对象成员的引用 8.5 的封装性和信息隐蔽 8.6 对象的简单应用举例
  • C++类成员函数返回对象及返回引用

    千次阅读 2021-11-22 15:54:40
    C++类函数返回对象的引用一、代码例题二、返回引用三、返回对象 一、代码例题 #include <iostream> using namespace std; class machine; ostream& operator<<(ostream& o,const ...
  • C++ 类对象的初始化

    千次阅读 2021-04-13 20:50:08
    c语言不同,在面向对象的编程中,使用构造函数对数据成员进行初始化,有多种方式。 录: 一、无参数的构造函数 二、带参数的构造函数 三、使用构造函数的参数初始化表 四、带默认参数的构造函数 对各种方式的描述...
  • c++类成员对象

    千次阅读 2018-06-11 18:00:52
    成员对象的构造析构 1、出现成员对象时,如果成员对象的构造函数是有参构造函数,则该的初始化列表需要对成员对象进行初始化。 class Member { private: int i; public: Member(int i) { this-&gt;i...
  • c++类对象作为方法参数(即函数参数)

    万次阅读 多人点赞 2019-09-12 17:13:03
    c++类对象作为参数传递时,有三种传递方式 #include <iostream> using namespace std; //求圆的面积 class Mycircle{ public: double r; double s; public: double getR(){ return r; } void setR...
  • C++类对象数组

    万次阅读 多人点赞 2018-05-14 23:47:15
    C++类对象数组 【1】对象数组 1:对象数组的定义:类名 数组名[元素个数] Eg: student asa[10];//有10个元素的学生类对象数组 2:对象数组的访问形式:数组名[下标].成员名; Eg: asa[j].print(); 3:对象...
  • C++类对象(下)——初始化列表、static成员和友元

    千次阅读 多人点赞 2021-03-08 09:23:18
    C++类对象——初始化列表、static成员和友元一、再谈构造函数1.1 构造函数整体赋值1.2 初始化列表三级目录 关于C++类对象的学习 C++类对象(上)——的基本概念、的限定符及封装和成员函数的this指针 C++...
  • C++类对象的概念及定义

    千次阅读 2018-07-07 19:59:12
    一. 什么是面向对象?1. 面向对象的定义 面向...所以,对象也就可以看做是的具体实例,我们就可以把看做建房子的图纸,对象就可以看做建出来的房子。将对象作为程序的基本单元,将程序和数据封装在其中,以提高...
  • C++类对象的内存模型

    千次阅读 2019-05-06 15:40:55
    C++类对象模型中,的所有普通成员函数都被放在一个特殊的位置,所有这个对象都共用这份成员函数。 虽然调用不同对象的成员函数时都是执行同一段函数代码,但是执行结果一般是不相同的。不同的对象使用的...
  • C++ 对象基础

    千次阅读 2021-03-10 10:33:17
    C++ 对象基础 结构化程序设计 结构化程序设计的概念:是进行以**模块**功能和处理过程设计为主的详细设计的基本原则。结构化程序设计是面向过程程序设计的一个子集,它对写入的程序使用逻辑结构,使得理解和修改...
  • C++】什么是对象?什么是

    千次阅读 多人点赞 2021-03-27 18:47:32
    1.1 现实世界中的含义:1.2 程序设计中的含义:2、什么是? 1、什么是对象? 什么是对象?作为一个二十多岁的年轻人,乍一看,这还用说,当然就是结婚的对象啦。当然可以这样理解,但是世界这么大,我也想去看看万物...
  • //千万要注意对那个构造出来的对象一定要使用初始化列表把所有的数据成员都初始化了。 person(string name1, string name2,string name3) :per_name(name1), sname(name2,name3) { cout 的构造函数被调用" ; ...
  • c++类中的临时对象

    千次阅读 2017-07-29 15:25:25
    1. c++临时对象的引入直接主题,上代码,#include class cls { public: int a; cls(int i) { a = i; } cls() { cls(0); } void show() { std::cout << "a = "
  • 第9章 C++类对象(二),内容 9.1 构造函数 9.2 析构函数 9.3 调用构造函数和析构函数的顺序 9.4 对象数组 9.5 对象指针 9.6 共用数据的保护 9.7 对象的动态建立和释放 9.8 对象的赋值和复制 9.9 静态成员...
  • c++三种实例化对象方式

    千次阅读 2022-04-16 18:47:15
    首先我们定义一个测试 class Person { private: int age; string name; public: Person() { cout<<"this is construct~"; } Person(int age, string name) { this->age = age; this-
  • C++创建对象的两种方法

    千次阅读 2019-12-24 10:59:19
    创建 现有一个学生Student,它的定义如下: class Student{ ...常见的C++创建对象的两种方法如下: 第一种: Student stu; stu.name = “xiaoming”; stu.age = 20; stu.score = 9...
  • C++类对象的内存布局

    千次阅读 多人点赞 2019-10-29 10:17:26
    1、C++类对象的内存布局 在C++类对象中,有两种类的成员变量:static和非static,有三种成员函数:static、非static和virtual。那么,它们在C++的内存中是如何分布的呢? C++程序的内存格局通常分为四个区:...
  • 区分“派生类对象”和“派生”对基类成员的访问权限 文字部分来源:https://blog.csdn.net/weixin_34283445/article/details/90683769 区分“派生类对象”和“派生”对基类成员的访问权限。  “派生类对象...
  • C++编程语言中类对象的赋值复制介绍(一)

    万次阅读 多人点赞 2018-08-20 17:17:07
    本系列文章主要介绍 C++ 编程语言中类对象的赋值操作、复制操作,以及两者之间的区别,另外还会介绍“深拷贝”“浅拷贝”的相关知识。 本文为系列文章的第一篇,主要介绍 C++ 编程语言中类对象的赋值的相关知识。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,114,613
精华内容 445,845
关键字:

c++类与对象

c++ 订阅
友情链接: grouse.rar