面向对象编程（OOP）

特征：抽象、多态、封装、继承

类

既然有结构体struct了，那么使用类class的好处是什么呢？C中struct的成员可以任意访问，对于一些隐私信息是不允许的。为了保护类中的数据安全，在C++中将类中的成员分为两类：公有成员（用public声明）；私有成员（用private声明）

私有成员（包括数据成员和成员函数)只能被类内的成员函数访问，不能被类外的对象访问。

公有成员（包括数据成员和成员函数)既可以被类内的成员函数访问，又可以被类外的对象访问。

实现类的外部接口

如果不添加pubic,类内的所有成员默认私有，而C的结构体默认公有。一般来说，把需要保护的数据设为私有，成员函数设为公有。成员函数为进入类的入口。

类的定义一般形式

class 类名{
    数据成员类型 数据成员列表
};

每个类可以没有成员，也可以有多个成员

类成员可以是数据或函数

所有成员必须在类的内部声明，一旦类定义完成后，没有其他方式添加成员。

每个类还可以包含成员函数，能够访问类自身的所有成员

类的数据成员

class Cube{
    long color;//数据成员
    double x,y,z,side;//数据成员
    int a[10];
    char *s;
    char &r;
    void *p;
}

内联成员函数

类的成员函数可以指定为inline，即内联函数。
默认情况下，在类体中定义的成员函数若不包括循环等控制结构符合内联函数要求时，C++会自动将它们作为内联函数处理(隐式inline)。

class Data { //Data类定义
    int getx(){ return x;} //内联成员函数
    inline int gety(){return y;} //显式指定内联成员函数
    inline void setxy(int_x，int_y)://显式指定内联成员函数
    void display();
    int x，y;
}；
inline void Data::setxy(intx，int_y)//内联成员函数
{
    x=_x，y=_y;
}
void Data::display()//非内联成员函数
{
    ... //函数体
}

在类的外部定义成员函数 

class 类名{
    返回类型 函数名（类型1 参数名1，类型2 参数名2,...);
    //成员函数声明
    返回类型 函数名（类型1，类型2，...);
};
返回类型 类名::函数名（形式参数列表）
{
    函数体//访问类的数据成员
}

说明：(::)是作用域限定符

成员函数重载及默认参数

成员函数的存储方式

通常，C++会为每个对象的数据成员分配各自独立的存储空间，像结构体成员那样。

类的声明

class Point;//Point类声明，非Point类定义

 在创建类的对象之前，必须完整地定义该类。这样，编译器就会给类的对象准备相应的存储空间。
同样地，在使用引用或指针访问类的成员之前，必须已经定义类。
类不能具有自身类型的数据成员。然而，只要类名一经出现就可以认为该类己声明。因此，类的数据成员可以是指向自身类型的指针或引用。

class Point;//Point类声明，非Point类定义，因为没有类体
class Line {
    Point a;//错误，不能使用仅有类声明而没有类定义的类定义数据对象
    Point *pp，&rp;//正确，只有类声明，即可用它定义该类的指针或引用
    Line b;//错误，类不能具有自身类型的数据成员
    Line*pl，&rl;//正确，类可以有指向自身类型的指针或引用的数据成员
}；

对象 

对象是类的实例

对象的定义 

1、先定义类类型再定义对象

类名 对象名列表；

2、定义类类型的同时定义对象 

class 类名{ //类体

        成员列表

}对象名列表；

一般而言，定义类型时不分配存储空间，定义对象时将为其分配存储空间 

对象的动态建立和释放

利用new运算符可以动态地分配对象空间，delete运算符释放对象空间。

用new运算动态分配得到的对象是无名的，它返回对象的内存单元的起始地址。程序通过这个地址可以间接访问这个对象，因此需要定义一个指向类的对象的指针变量来存放该地址。
在执行new运算时，如果内存不足，无法开辟所需的内存空间C++编译器会返回一个0值指针。因此，只要检测返回值是否为0.就可以判断动态分配对象是否成功，只有指针有效时才能使用对象指针。

当不再需要使用由new建立的动态对象时，必须用delete运算予以撤销。例如:

delete p;//撤销p所指向的Point对象

释放了p所指向的对象。此后程序不能再使用该对象，
注意，new建立的动态对象不会自动被撤销，即使程序运行结束也是如此，必须人为使用delete撤销

访问对象中的成员可以有3种方法

1、通过对象名和对象成员引用运算符(.)访问对象中的成员；

对象名.成员

对象名.成员函数（实参列表）

从类外部只能访问公有成员

2、通过指向对象的指针和指针成员引用运算符(->)访问对象中的成员;

对象指针->成员

对象指针->成员函数（实参列表）

3、通过对象的引用变量和对象成员引用运算符(.)访问对象中的成员;

对象引用变量名.成员

对象引用变量名.成员函数（实参列表）

对象赋值（同类）

对象名1=对象名2；

构造函数

创建对象时自动被调用（ctor）

在创建对象时初始化对象，为对象数据成员赋初始值

类的数据成员不能在类定义时初始化（原因：类定义时并没有产生一个实体，而是建立一种数据模型，不占用内存空间）

如果一个类中所有数据成员都是共有的，则可以在定义对象时对数据成员初始化

构造函数的定义

C++规定构造函数的名字与类的名字相同，并且不能指定返回类型。定义形式为:

类名(形式参数列表)

{

函数体

}

构造函数可以没有形参，有如下两种形式:

类名()

{

函数体

}

类名(void)

{
函数体

}

关于构造函数的说明:
(1)构造函数是在创建对象时自动执行的，而且只执行一次，并先于其他成员函数执行。构造函数不需要人为调用，也不能被人为调用。
(2)构造函数一般声明为公有的(public)，因为创建对象通常是在类的外部进行的。如果构造函数声明为保护的(protected)或私有的(protected)，那就意味着在类外部创建对象(并调用构造函数)是错误的。换言之，这样的类是不能由外部实例化，只能由类内部实例化，这种情况不是通常的做法。

(3)在构造函数的函数体中不仅可以对数据成员初始化,而且可以包含任意其他功能的语句，例如分配动态内存等，但是一般不提倡在构造函数中加入与初始化无关的内容
(4)每个构造函数应该为每个数据成员提供初始化。否则将使那些数据成员处于未定义的状态。而使用一个未定义的成员是错误的
(5)带参数的构造函数中的形参，是在定义对象时由对应的实参给定的，用这种方法可以方便地实现对不同对象进行不同的初始化，需要注意，实参必须与构造函数的形参的个数、次序、类型一致。

构造函数的重载

在一个类中可以定义多个构造函数版本，即构造函数允许被重载只要每个构造函数的形参列表是唯一的。一个类的构造函数数量是没有限制的。一般地，不同的构造函数允许建立对象时用不同的方式来初始化数据成员。

尽管在一个类中可以包含多个构造函数，但是对于每一个对象来说建立对象时只执行其中一个，并非每个构造函数都被执行。

带默认参数的构造函数

例

1、必须在类内指定默认参数

2、如果构造函数的全部参数都指定了默认值，则在定义对象时可以给一个或几个实参，也可以不给出实参。这时，就与无参数的构造函数有歧义了。

3、在一个类中定义了带默认参数的构造函数后，不能再定义与之有冲突的重载构造函数。

拷贝构造函数

拷贝构造函数，又称复制构造函数，是一种特殊的构造函数，它由编译器调用来完成一些基于同一类的其他对象的构建及初始化。其形参必须是引用，但并不限制为const，一般普遍的会加上const限制。 

对于普通类型的对象来说，它们之间的复制是很简单的，例如：

int a = 100;
int b = a; 

而类对象与普通对象不同，类对象内部结构一般较为复杂，存在各种成员变量。
下面看一个类对象拷贝的简单例子。

类名（const 类名 &参数）

#include<iostream>
using namespace std;
class CExample
{
private:
    int a;
public:
    //构造函数
    CExample(int b)
    {
        a=b;
        printf("constructor is called\n");
    }
    //拷贝构造函数
    CExample(const CExample & c)
    {
        a=c.a;
        printf("copy constructor is called\n");
    }
    //析构函数
    ~CExample()
    {
        cout<<"destructor is called\n";
    }
    void Show()
    {
        cout<<a<<endl;
    }
};
int main()
{
    CExample A(100);
    CExample B=A;
    B.Show(); 
    return 0;
}

程序运行结果如下：

constructor is called
copy constructor is called
100
destructor is called
destructor is called          

使用条件

析构函数 

析构函数:

当对象脱离其作用域时(例如对象所在的函数已调用完毕)，系统会自动执行析构函数。（dtor)析构函数往往用来做“清理善后的工作(例如在建立对象时用new开辟了一段内存空间，则在该对象消亡前应在析构函数中用delete释放这段存储空间)

C++规定析构函数的名字是类名的前面加一个波浪号(~)。其定义形式为:

~类名()

{
        函数体

}

析构函数不返回任何值，没有返回类型，也没有函数参数。由于没有函数参数，因此它不能被重载。换言之，一个类可以有多个构造函数，但是只能有一个析构函数，

何时调用析构函数:

(1)对象在程序运行超出其作用域时自动撤销，撤销时自动调用该对象的析构函数。如函数中的非静态局部对象
(2)如果用new运算动态地建立了一个对象，那么用delete运算释放该对象时，调用该对象的析构函数。

需要特别注意对它们的调用时间和在使用构造函数和析构函数时，调用次序。
构造函数和析构函数的调用很像一个栈的先进后出，调用析构函数的次序正好与调用构造函数的次序相反。最先被调用的构造函数其对应的(同一对象中的)析构函数最后被调用，而最后被调用的构造函数，其对应的析构函数最先被调用。
可简述为:先构造的后析构，后构造的先析构。

调用次序

对象数组和对象指针

对象数组

将具有相同类类型的对象有序地集合在一起便构成了对象数组，以一维对象数组为例，其定义形式为:

类名 对象数组名[常量表达式];

一维对象数组有时也称为对象向量，它的每个元素都是相同类类型的对象。

例如表示平面上若干个点，可以这样定义:
Point points[100];//表示100个点

关于对象数组的说明:
(1)在建立对象数组时，需要调用构造函数。如果对象数组有100个元素，就需要调用100次构造函数。
(2)如果对象数组所属类有带参数的构造函数时，可用初始化列表按顺序调用构造函数，使用复制初始化来初始化每个数组元素。(3)如果对象数组所属类有单个参数的构造函数时，定义数组时可以直接在初值列表中提供实参。
Point P[3]={Point(1,2),Point(5,6),Point(7,8)};//三个实参Student S[5]={20,21,19,20,19};//Student类只有一个数据成员

(4)对象数组创建时若没有初始化，则其所属类要么有合成默认构造函数(此时无其他的构造函数)，要么定义无参数的构造函数或全部参数为默认参数的构造函数(此时编译器不再合成默认构造函数)
(5)对象数组的初始化式究竟是什么形式，，本质上取决于所属类的构造函数。因此，需要明晰初始化实参与构造函数形参的对应关系，避免出现歧义性。
(6)如果对象数组所属类含有析构函数，那末每当建立对象数组时，按每个元素的排列顺序调用构造函数;每当撤销数组时，按相反的顺序调用析构函数。

对象指针

在建立对象时，编译器会为每一个对象分配一定的存储空间，以存放其成员。对象内存单元的起始地址就是对象的指针。可以定义一个指针变量，用来存放对象的指针。指向类对象的指针变量的定义形式为:

类名 *对象指针变量名 =初值

例

文章内容来源

C++程序设计_中国大学MOOC(慕课) (icourse163.org)

一文看懂C++类的拷贝构造函数所有用法（超详细！！！）-CSDN博客