1.类是一种抽象数据类型，本身不占用内存空间，当分配对象后才会占用内存空间,对数据以及操作数据的方法进行封装。
class Student { protected: int age; //成员变量 string name; public: void sleep(){};//成员函数 void study(){}; void eat(){};· };
类中的成员权限分为三种：public、private、protected
| public | 在类外可以通过对象直接访问 |
| public | 对外隐藏， 对子类开放，类内部使用（在类的成员函数中使用） |
| private | 对外隐藏， 只能在类内部使用（在类的成员函数中使用） |
| 没有指定权限 | 默认是私有权限，对外隐藏 |
2.构造与析构函数
构造函数
1. 函数名与类名相同
2. 函数没有返回值（也不能是void）
3. 在创建类对象后自动调用(不能自己调用)
4. 如果没有自定义构造函数，编译器系统会自动生成一个不带参数的构造函数
析构函数：
1. 函数名是在类名前面添加~
2. 函数没有返回值，也么有参数
3. 函数在对象销毁的时候自动调用
4. 如果没自定义析构函数，系统会自动生成一个析构函数
#include <iostream> using namespace std; class Person{ public: Person()//构造函数 { cout<<"Person()"<<endl; sex = "女"; } ~Person()//析构函数 { cout<<"~Person()"<<endl;
}
private:
int age;
string name;
string sex;
protected:
};
构造函数是可以带参数的，如下：
class Person{ public: Person(string s,char *n,int age)//构造函数带着三个参数 { cout<<"Person()"<<endl; sex=s; name=new char[32]; strcpy(name,n); this->age=age; } }
如果没有其他的构造函数，在创建对象的时候必须制定这三个参数
Person jack("男"，"jack",18);//传参数给构造函数
this指针：在类的成员函数中会隐含一个对象的指针参数，this代表的是谁调用函数，那么就用谁的this指针，this指针一般用来区分成员变量与函数中的局部变量的冲突。
构造函数重载
Person jack;//可以类中重载 Person::Person();
Person jack("男","jack",18） Person::Person(string s,const char *n,int age)
class Person{ public: Person() { cout<<"Person()"<<endl; sex="男"; name=new char[32]; strcpy(name,"jack"); this->age=19; } //重载的构造函数 Person(string s,const char *n,int age) { cout<<"Person(string,char *,int")<<endl; sex=s; name=new char[32]; strcpy(name,n); this->age=age; } }
构造函数缺省参数
class Person{ public: //构造函数 Person(string s="男"，const char *n="jack",int age=19) { cout<<"Person(string,char *,int")<<endl; sex=s; name=new char[32]; strcpy(name,n); this->age=age; } }
//创建对象
Person jack0;//调用不带参数的构造函数
Person jack("男"，"jack",18);//给参数的构造函数
构造函数-成员参数列表初始化，格式：
Person(string s="男",char *n="jack",int age=19):sex(s),age(age){...}
把括号里面的内容（参数，常量..）赋值给括号外面的成员，成员参数列表初始化，在创建类对象的时候申请空间同时立即（用括号里面的值）初始化
应用：1.成员变量是常量
2.继承的时候调用父类的构造函数
类的成员函数在类内声明，类外实现
//成员函数在类内声明 class Person{ public: Person(string s="男",char *n="jack",int age=19)//声明部分写默认参数 ~Person(); void show(); private: int age; char *name; string sex; protected: } //成员函数在类外实现 Person::Person(string s,char *n,int age):age(age),sex(s){}//实现对部分成员参数列表的初始化 Person::~Person(){} void Person::show(){}
拷贝构造函数
1.拷贝构造函数也是构造函数，参数是一个对象的引用
2.如果没有自定义拷贝构造函数，系统会自动生成一个默认的拷贝构造函数（浅拷贝）
3.下面的情况会调用拷贝构造函数
Person jack("男","jack",19); Person rose=jack; Person rose(jack);
浅拷贝---系统默认就是，不需要自己去实现，格式：Person(Person& p);
class Person{ public: //构造函数的声明 Person(const char *name="jack",string sex="man",int age=18); //拷贝构造 Person(Person& p); ~Person(); void show(); private: char *name; string sex; int age; } //构造函数逇实现 Person::Person(const char *name,string sex,int age):sex(sex),age(age) { cout<<"Person()"<<endl; this->name=new char[32]; strcpy(this->name,name); } Person::Person(Person& p) { cout<<"Person(Person& p)"<<endl; //浅拷贝只对对象成员进行赋值 this->age=p.age; this->sex=p.sex; this->name=p.name; } Person::~Person() { delete []name; } void Person::show(){}
深拷贝---需要自己去实现，拷贝对象本身空间的同时还要拷贝成员指向的堆空间
#include <iostream> #include <cstring> using namespace std; class Person{ public: //构造函数声明 Person(const char *name="jack",string sex="man",int age=16); //拷贝构造 Person(Person& p); ~Person(); void show(); private: char *name; string sex; int age; } //构造函数实现 Person::Person(const char *name,string sex,int age):sex(sex),age(age) { cout<<"person()"<<endl; this->name=new char[32]; strcpy(this->name,nama); } Person::Person(Person& p) { cout<<"Person(Person&"<<endl; //深拷贝--拷贝对象空间的同时还要拷贝成员指向的堆空间 this->age=p.age; this->sex=p.sex; this->name=p.name; strcpy(this->name,p.name); } Person::~Person() { cout<<"~Person()"<<endl; delete []name; } void Person::show(){} int main() { //创建对象 Person jack("man","jack",20); jack.show(); //拷贝构造创建对象 Person rose(jack); rose.show(); return 0; }
PS：如果有哪里写错了，请指正，大家互相学习。
原文：https://www.cnblogs.com/smallqizhang/p/12462389.html