c++复习之类和对象进阶

构造函数？？

• 类中特殊成员函数，作用是对象进行初始化。没有定义，系统会自动添加一个不带参的构造函数。

• 声明形式 类名（形参1...）;//也可以没有

• 定义形式
  类名::类名（形参1...）：x1(形参1),x2(形参2）...{ };//将形参1给x1赋值，函数体为空
类名::类名（形参1...）{x1=形参1...};//函数体里赋值
类名::类名(){x1=初始化表达式...};//成员变量所赋初值都是固定的，形参为空
  构造函数不能指明返回类型，不要返回值，即使void也不可以
  可以有多个构造函数，函数重载
  参数没有顺序要求，只要保证相互对应即可
  在程序中说明一个对象时，程序自动调用构造函数来初始化该对象
  使用构造函数，构造函数名 对象名（形参）

• 复制构造函数
  作用：使用一个已存在的对象初始化另一个正在创建的对象。
  原型：
  类名::类名（类名&）//对象的引用作为形参或
  类名::类名（const 类名&）//为了不改变原有对象
  声明：

class 类名
{
public:
     类名（形表表）；//构造函灵敏
     类名（类名 &对象名）;//声明复制构造函数
};
类名::类名（类名&对象名)//复制构造函数实现
{
函数体
}

• 类型转换构造函数
  只有一个参数的构造函数（复制构造函数除外）.作用是使一个其他类型的变量或常量自动转换成一个临时对象。实现的是从参数类型到该类类型的转换。

析构函数？？？

作用：释放由构造函数分配的内存
声明形式：~类名()
定义形式:类名::~类名(){}
类只能定义一个析构函数，且不能指明参数，也没有返回值
如果没有定义的话，编译器自动生成默认的析构函数，函数体为空。
使用new运算符动态分配内存空间，由在析构函数中应该使用delete释放掉这部分占用的空间
先后创建对象的，按照创建相反顺序析构。
对象生存期结束，系统会自动调用析构函数完成空间的释放。

静态变量？？？

静态全局变量：
在所有花括号之外声明的变量，在整个项目文件都有效。用static修饰。
静态局部变量:在块内定义的static变量。 只在块内有效。
静态变量存储在全局数据区，静态变量只执行一次初始化，未初始化，系统将赋0.

类的静态成员：
静态成员变量和静态成员函数
在类体内定义成员时，在前面加上static

• 静态成员变量不能在类体内赋值.如下所示：

#include <iostream>
using namespace std;

class classA
{
	public:
		double x, y;
		static int num; //公有静态成员变量，供所有的对象共享
		//用于记录通过构造函数已经生成的对象的个数
		classA()
		{		
			x = 0;
			y = 0;
			num++;
		}
		classA(double x0, double y0)
		{
			x = x0;
			y = y0;
			num++;
		}
		static void staticFun()
		{
			cout << "current_num=" << num << endl;	
			//cout << "x=" << x << endl; //错误 在静态函数中不可以访问非静态成员
		}
};
int classA::num = 0; //必须在类体外（使用类名限定初始化静态成员变量

int main()
{
	classA obj(1.2, 3.4),*p;
	cout << "classA::num=" << classA::num << endl; //使用类名做限定符
	classA::staticFun();
	cout << "obj.num =" << obj.num << endl; //使用对象名称限定符
	obj.staticFun();
	cout << endl;
	classA A[3]; //调用三次构造函数
	cout << "class A::num=" << classA::num << endl;
	classA::staticFun();
	cout << endl;
	p = new classA(5.6, 7.8);
	cout << "classA::num=" << classA::num << endl;
	classA::staticFun();
	cout << "p->num =" << p->num << endl;
	p->staticFun();
	return 0;
}

在体外赋初值：类型 类名::静态成员变量=初值。
在类体外定义成员函数时，前面也不能加static
类的静态成员被类的所有对象共享
静态函数内不能调用非静态成员函数。
访问静态成员和一般成员访问一样。
类名：：静态成员变量
对象名.静态成员变量
指针->静态成员变量

与一般成员函数的不同
静态成员函数可以不指向某个具体的对象，只与类名连用
没有建立对象前，静态成员就已经存在了
静态成员是类的成员，不是对象的成员
静态成员为该类所有对象所共享，存储于一个公用内存中
没有this指针，只能对象名或指向对象的指针访问
不能被说明为虚函数
不能直接访问非静态函数
静态对象与普通对象不同
静态对象的构造函数执行过程中，只在第一次遇到它的变量定义并初始化时被调用，直到整个程序结束之前仅调用一次，而普通对象是遇到几次调用几次
静态对象的析构函数在整个程序退出之前被调用，也只调用一次，普通对象也是定义几次析构几次

变量的生存期和作用域

生存期指变量得到内存空间到释放的时期
作用域变量的作用范围
全局变量：从变量定义到整个程序结束，生存期是整个程序的执行期间
局部变量:块内，生存期就是到块结束
类的对象：生存期是从生成对象（调用构造函数开始）到调用析构函数结束
作用域和变量作用域一样。

常量成员和常引用成员

类常量成员变量：由const修饰的类成员变量
格式：
const 数据类型 类常量成员变量=表达式；
必须进行初始化，而且只能通过构造函数成员列表的方式进行

常量对象，用const声明的对象
必须在声明的同时进行初始化，而且不能被更新。
格式：
const 类名 对象名（参数表）;或类名 const 对象名（参数表）;
常量对象只能调用常量成员函数

常量函数：用const定义的成员函数
格式：
在类体内定义为内联函数的形式
类型标识符 函数名（参数列表）const{函数体}
在类体内声明，类体外定义的形式
声明形式：类型标识符 函数名（参数列表）const;
定义形式：类型标识符 类名::函数名（参数列表）const {函数体}
常量函数不能更新对象的数据成员，也不能调用没用const修饰的成员函数。

• 2021年4真题44：

#include <iostream>
using namespace std;
class Test
{
private:
    int n;
public:
    Test(int i = 16)
    {
        n = --i;
    }
    int Get()
    {
        return n;
    }
    int Get()const
    {
        return (n - 2);
    }
};
int main()
{
    Test a;
    const Test b(27);//常对象只能调用常成员函数
    cout << "the first number is" << a.Get() << endl;//调用构造函数 15
    cout << "the second numberis" << b.Get() << endl;//先调用构造函数-1,再减2,所以24.
    return 0;
}

常引用作为函数参数
作用：不希望改变引用对象的值
非常量对象会自动调用非常量同名函数，也可以调用常量函数

成员对象和封闭类？？？

成员对象：一个类成员变量是另一个类的对象。如student 下的 birthday
封闭类：包含成员对象的类。

初始化：

封闭类名::构造函数名(参数表）：成员变量（参数表），成员变量2(参数表){}
执行封闭类的构造函数时，先执行成员对象的构造函数，再执行本类的构造函数。

消亡

先执行封闭类的析构函数，再执行成员对象的析构函数

成员对象构造函数调用顺序

和成员对象在类中的说明顺序一致
与在成员初始化列表中出现的顺序无关

封闭类的复制构造函数

如果封闭类的对象是用默认复制构造函数初始化的，那么它包含的成员对象也用复制构造函数初始化

友元？？？考点

友元机制是对一些类外的函数，能够访问本类的私有成员变量。详见c++考点之友元

友元函数：

在定义一个类的时候，可以把一些函数（包括全局函数和其他类的成员函数）声明为“友元”，这样那些函数成为本类的友元函数。
定义形式：
friend 函数类型 函数名（参数列表）;//全局函数
friend 函数类型 函数所在类名::函数名（参数列表）；//其他类的函数
在类中声明，在类外定义，就不能再在类外使用friend关键字。

友元类：

如果将一个类B说明为另一个类A的友元类，则类B中的所有函数都是类A的友元函数。
形式：
friend class 类名；
友元类的关系是单向的。也不是传递的
一般情况不使用。

this指针？？

成员函数被调用时，会传递一个this指针。指向调用成员函数的对象，友元函数不是通过对象调用的，所以没有this指针。静态成员是类的属性，不是对象的特征，所以静态成员函数没有this指针。形式为：

this与*this this->

脑子里的记忆是“谁调用这个函数(指类的成员函数，也就是哪个对象），this就指向谁”，这个是没错的，但具体在java或C++如何实现的呢？一直以来也没有探究过。this是实现封装的一种形式。
this：就是类的对象的指针
*this:解引用，也就是指针的内容，即对象本身
this ->:这个在c++中是可省的，取对象指针里的属性或操作。