类的定义
类可以看做是一种数据类型，类这种数据类型是一个包含成员变量和成员函数的集合。类的成员变量和普通变量一样，也有数据类型和名称，占用固定长度的内存。但是，在定义类的时候不能对成员变量赋值，因为类只是一种数据类型或者说是一种模板，本身不占用内存空间，而变量的值则需要内存来存储。
类的成员函数也和普通函数一样，都有返回值和参数列表，它与一般函数的区别是：成员函数是一个类的成员，出现在类体中，它的作用范围由类来决定；而普通函数是独立的，作用范围是全局的，或位于某个命名空间内。实例1：
#include <iostream>using namespace std;//类通常定义在函数外面class Student{public://类包含的变量char *name;int age;float score;//类包含的函数void say(){cout << name << "的年龄是" << age << "，成绩是" << score << endl;}};int main(){//创建对象Student stu;stu.name = "小明";stu.age = 15;stu.score = 92.5f;stu.say();return 0;}
实例1中在类体中定义了成员函数，也可以只在类体中声明函数，在类体中直接定义函数时，不需要在函数名前面加上类名，因为函数属于哪一个类是很明显的。但当成员函数定义在类外时，就必须在函数名前面加上类名予以限定。::被称为域解析符（也称作用域运算符或作用域限定符），用来连接类名和函数名，指明当前函数属于哪个类。
成员函数必须先在类体中作原型声明，然后在类外定义，也就是说类体的位置应在函数定义之前。
class Student{public://成员变量char *name;int age;float score;//成员函数void say(); //函数声明};//函数定义void Student::say(){cout << name << "的年龄是" << age << "，成绩是" << score << endl;}
虽然 C++ 支持将内联函数定义在类的外部，但建议将函数定义在类的内部，这样它会自动成为内联函数，何必费力不讨好地将它定义在类的外部呢，这样并没有任何优势。类的定义可以使用指针形式，并使用“->”初始化，实例2：
#include <iostream>using namespace std;class Student{public:char *name;int age;float score;void say(){cout << name << "的年龄是" << age << "，成绩是" << score << endl;}};int main(){Student *pStu = new Student;pStu->name = "小明";pStu->age = 15;pStu->score = 92.5f;pStu->say();delete pStu; //删除对象return 0;}
实例2在堆上创建对象，需要使用new关键字，在栈上创建出来的对象都有一个名字，比如 stu，使用指针指向它不是必须的。但是通过 new 创建出来的对象就不一样了，它在堆上分配内存，没有名字，只能得到一个指向它的指针，所以必须使用一个指针变量来接收这个指针，否则以后再也无法找到这个对象了，更没有办法使用它。也就是说，使用 new 在堆上创建出来的对象是匿名的，没法直接使用，必须要用一个指针指向它，再借助指针来访问它的成员变量或成员函数。
类成员的访问权限：
C++通过 public、protected、private 三个关键字来控制成员变量和成员函数的访问权限，它们分别表示公有的、受保护的、私有的，被称为成员访问限定符。所谓访问权限，就是你能不能使用该类中的成员。C++ 中的 public、private、protected 只能修饰类的成员，不能修饰类，C++中的类没有共有私有之分。在类的内部（定义类的代码内部），无论成员被声明为 public、protected 还是 private，都是可以互相访问的，没有访问权限的限制。在类的外部（定义类的代码之外），只能通过对象访问成员，并且通过对象只能访问 public 属性的成员，不能访问 private、protected 属性的成员。见实例3：
#include <iostream>using namespace std;//类的声明class Student{private: //私有的char *m_name;int m_age;float m_score;public: //共有的void setname(char *name){m_name = name;}void setage(int age){m_age = age;}void setscore(float score){m_score = score;}void show(){cout << m_name << "的年龄是" << m_age << "，成绩是" << m_score << endl;}};int main(){//在栈上创建对象Student stu;stu.setname("小明");stu.setage(15);stu.setscore(92.5f);stu.show();//在堆上创建对象Student *pstu = new Student;pstu->setname("小红");pstu->setage(16);pstu->setscore(96);pstu->show();return 0;}
成员变量大都以m_开头，这是约定成俗的写法，不是语法规定的内容。以m_开头既可以一眼看出这是成员变量，又可以和成员函数中的形参名字区分开。实例3中的m_name、m_age、m_score 是私有成员变量，不能在类外部通过对象访问。如下定义就是一种错误的表示：
Student stu;stu.m_name = "小明";stu.m_age = 15;stu.m_score = 92.5f;stu.show();
这种将成员变量声明为 private、将部分成员函数声明为 public 的做法体现了类的封装性。所谓封装，是指尽量隐藏类的内部实现，只向用户提供有用的成员函数。private 关键字的作用在于更好地隐藏类的内部实现，该向外暴露的接口（能通过对象访问的成员）都声明为 public，不希望外部知道、或者只在类内部使用的、或者对外部没有影响的成员，都建议声明为 private。
根据C++软件设计规范，实际项目开发中的成员变量以及只在类内部使用的成员函数（只被成员函数调用的成员函数）都建议声明为 private，而只将允许通过对象调用的成员函数声明为 public。另外还有一个关键字 protected，声明为 protected 的成员在类外也不能通过对象访问，但是在它的派生类内部可以访问。
声明为 private 的成员和声明为 public 的成员的次序可以是任意的，既可以先出现 private 部分，也可以先出现 public 部分。如果既不写 private 也不写 public，默认为 private。在一个类体中，private 和 public 可以分别出现多次。但是为了使程序清晰，应该养成使每一种成员访问限定符在类定义体中只出现一次的习惯。
类的构造函数：
在C++中，有一种特殊的成员函数，它的名字和类名相同，没有返回值，不需要用户显式调用（用户也不能调用），而是在创建对象时自动执行。这种特殊的成员函数就是构造函数。实例3中，通过成员函数 setname()、setage()、setscore() 分别为成员变量 name、age、score 赋值，这样做虽然有效，但显得有点麻烦。有了构造函数，我们就可以简化这项工作，在创建对象的同时为成员变量赋值。见实例4：#include <iostream>using namespace std;class Student{private:char *m_name;int m_age;float m_score;public://声明构造函数Student(char *name, int age, float score);//声明普通成员函数void show();};//定义构造函数Student::Student(char *name, int age, float score){m_name = name;m_age = age;m_score = score;}//定义普通成员函数void Student::show(){cout << m_name << "的年龄是" << m_age << "，成绩是" << m_score << endl;}int main(){//创建对象时向构造函数传参Student stu("小明", 15, 92.5f);stu.show();//创建对象时向构造函数传参Student *pstu = new Student("小红", 16, 96);pstu->show();return 0;}
实例4，在 Student 类中定义了一个构造函数Student(char *, int, float)，它的作用是给三个 private 属性的成员变量赋值。要想调用该构造函数，就得在创建对象的同时传递实参，并且实参由( )包围，和普通的函数调用非常类似。在栈上创建对象时，实参位于对象名后面，例如Student stu("小明", 15, 92.5f)；在堆上创建对象时，实参位于类名后面，例如new Student("小红", 16, 96)。
构造函数必须是 public 属性的，否则创建对象时无法调用。设置为 private、protected 属性不会报错，但没有意义。构造函数没有返回值，因为没有变量来接收返回值，即使有也毫无用处，这意味着：（1）不管是声明还是定义，函数名前面都不能出现返回值类型，即使是 void 也不允许；（2）函数体中不能有 return 语句。
构造函数的调用是强制性的，一旦在类中定义了构造函数，那么创建对象时就一定要调用，不调用是错误的。如果有多个重载的构造函数，那么创建对象时提供的实参必须和其中的一个构造函数匹配；反过来说，创建对象时只有一个构造函数会被调用。
实例4中的代码，如果写作Student stu或者new Student就是错误的，因为类中包含了构造函数，而创建对象时却没有调用。
如果用户没有定义构造函数，那么编译器会自动生成一个默认的构造函数，只是这个构造函数的函数体是空的，没有形参，也不执行任何操作。比如上面的 Student 类，默认生成的构造函数如下：Student(){}。
一个类必须有构造函数，要么用户自己定义，要么编译器自动生成。一旦用户自己定义了构造函数，不管有几个，也不管形参如何，编译器都不再自动生成。和普通成员函数一样，构造函数是允许重载的。一个类可以有多个重载的构造函数，创建对象时根据传递的实参来判断调用哪一个构造函数。
#include <iostream>using namespace std;class Student{private:char *m_name;int m_age;float m_score;public:Student();Student(char *name, int age, float score);void setname(char *name);void setage(int age);void setscore(float score);void show();};Student::Student(){m_name = NULL;m_age = 0;m_score = 0.0;}Student::Student(char *name, int age, float score){m_name = name;m_age = age;m_score = score;}void Student::setname(char *name){m_name = name;}void Student::setage(int age){m_age = age;}void Student::setscore(float score){m_score = score;}void Student::show(){if (m_name == NULL || m_age <= 0){cout << "成员变量还未初始化" << endl;}else{cout << m_name << "的年龄是" << m_age << "，成绩是" << m_score << endl;}}int main(){//调用构造函数 Student(char *, int, float)Student stu("小明", 15, 92.5f);stu.show();//调用构造函数 Student()Student *pstu = new Student();pstu->show();pstu->setname("小红");pstu->setage(16);pstu->setscore(96);pstu->show();return 0;}
类的拷贝构造函数：
拷贝构造函数是一种特殊的构造函数，函数的名称必须和类名称一致，它唯一的一个参数是本类型的一个引用变量，该参数是const类型，不可变的。例如：类X的拷贝构造函数的形式为X(X& x)。#include <iostream> using namespace std;class CExample {private:int a;public://构造函数 CExample(int b){a = b;}//拷贝构造函数 CExample(const CExample& C){a = C.a;}//一般函数 void Show(){cout << "a的值为："<<a<< endl;}};int main(){CExample A(10);CExample B = A; // CExample B(A); 也是一样的 B.Show();return 0;}
上面的例子中，CExample(const CExample& C)就是自定义的拷贝构造函数。拷贝分为浅拷贝和深拷贝两种，浅拷贝，指的是在对象复制时，只对对象中的数据成员进行简单的赋值，默认拷贝构造函数执行的也是浅拷贝。大多情况下“浅拷贝”已经能很好地工作了，但是一旦对象存在了动态成员，那么浅拷贝就会出问题了。在某些状况下，类内成员变量需要动态开辟堆内存，如果实行浅拷贝，即把对象里的值完全复制给另一个对象，如A=B。这时，如果B中有一个成员变量指针已经申请了内存，那A中的那个成员变量也指向同一块内存。这就出现了问题：当B把内存释放了（如：析构），这时A内的指针就是野指针了，出现运行错误。举个错误的例子：
class Rect { public: Rect()// 构造函数，p指向堆中分配的一空间 { p = new int(100); } ~Rect()// 析构函数，释放动态分配的空间 { if(p != NULL) { delete p; } } private: int width; int height; int *p;// 一指针成员 }; int main() { Rect rect1; Rect rect2(rect1); // 复制对象 return 0; }
上面例子中，执行的是浅拷贝：
我们需要的不是两个p有相同的值，而是两个p指向的空间有相同的值，解决办法就是使用“深拷贝”。深拷贝是指：如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝。正确的例子为：
class Rect { public: Rect()// 构造函数，p指向堆中分配的一空间 { p = new int(100); } Rect(const Rect& r) { width = r.width; height = r.height; p = new int; // 为新对象重新动态分配空间 *p = *(r.p); } ~Rect()// 析构函数，释放动态分配的空间 { if(p != NULL) { delete p; } } private: int width; int height; int *p;// 一指针成员 };
此时rect1的p和rect2的p各自指向一段内存空间，但它们指向的空间具有相同的内容，这就是所谓的“深拷贝”。
类的析构函数（Destructor）
析构函数(destructor) 与构造函数相反，当对象结束其生命周期时（例如对象所在的函数已调用完毕），系统自动执行析构函数。析构函数往往用来做“清理善后” 的工作（例如在建立对象时用new开辟了一片内存空间，应在退出前在析构函数中用delete释放）。触发条件：当对象被销毁时，会自动调用析构函数，释放资源。构造函数在对象实例化时自动调用，析构函数在对象销毁时自动调用。
析构函数（Destructor）也是一种特殊的成员函数，没有返回值，不需要程序员显式调用（程序员也没法显式调用），而是在销毁对象时自动执行。构造函数的名字和类名相同，而析构函数的名字是在类名前面加一个“~”符号。析构函数没有参数，不能被重载，因此一个类只能有一个析构函数。如果用户没有定义，编译器会自动生成一个默认的析构函数。
#include <string.h>#include <iostream>using namespace std;class stud{private://私有部分int num;char name[10];char sex;public://公用部分stud(int n, const char nam[], char s)//构造函数{num = n;strcpy_s(name, nam);sex = s;}~stud() //析构函数{cout << "stud has been destructed!" << endl;//通过输出提示告诉我们析构函数确实被调用了}void display()//成员函数，输出对象的数据{cout << "num:" << num << endl;cout << "name:" << name << endl;cout << "sex:" << sex << endl;}};int main(){stud stud1(10010, "Wangli", 'f'), stud2(10011, "Zhangfun", 'm');//建立两个对象stud1.display();//输出学生1的数据stud2.display();//输出学生2的数据return 0;}//主函数结束的同时，对象stud1，stud2均应被“清理”，而清理就是通过调用了析构函数实现的。
参考：
/mr-wid/archive//02/18/2916309.html
/cpp/biancheng/view/185.html
/lwbeyond/article/details/656/
/link?url=R4MhPpouXzfx9uUINgnUeSnWDzQCEnzLFwy41wmqEjiasMGrxXXI2Ogk6rAcSnpSlCEw_MvLPhQ90NhAXvk23CM2sntilP9UufOMzZ-8bPgqP-XMqrTSDhhCS_92qGu0
/qq_34803572/article/details/55213551
