cpp基础复习

不能返回局部变量引用

当函数调用作为左值式，函数返回必须是引用

引用的本质是内部实现了一个指针常量

//发现是引用，转换为 int* const ref = &a;
void func(int& ref){
	ref = 100; // ref是引用，转换为*ref = 100
}

使用引用的时候，在函数形参中加const，防止形参改变实参，但加了之后就不能做赋值或换值之类的操作了

函数中默认参数如果有，那么从第一个默认参数开始从左向右都是默认参数

函数重载满足条件：

• 同一个作用域下
• 函数名称相同
• 函数参数类型不同 或者 个数不同 或者 顺序不同
  注意：函数返回值不可以作为函数重载条件
  引用作为重载条件
  函数重载碰到函数默认参数会产生歧义，需要避免

定义类的时候记得最后的那个分号；

private是完全私有的，只有自己可以访问，派生类和外部都不可以访问
protected是受保护的，只有派生类可以访问，外部不能访问
在类外如果想使用类中的成员，只能直接使用public类型的，proteced和private都是不能访问的，对于类外而言，这两个是完全相同的。

在C++中 struct和class唯一的区别就在于 默认的访问权限不同
区别：

• struct 默认权限为公共
• class 默认权限为私有

复制构造函数是构造函数的一种，也称拷贝构造函数，它只有一个参数，参数类型是本类的引用。

如果类的设计者不写复制构造函数，编译器就会自动生成复制构造函数。大多数情况下，其作用是实现从源对象到目标对象逐个字节的复制，即使得目标对象的每个成员变量都变得和源对象相等

记得构造函数要放在public里面啊，不然在外面会默认为private的，就无法访问了。

	//2.2 显式法
	Person p2 = Person(10); 
	Person p3 = Person(p2);
	//Person(10)单独写就是匿名对象  当前行结束之后，马上析构

	//2.3 隐式转换法
	Person p4 = 10; // Person p4 = Person(10); 
	Person p5 = p4; // Person p5 = Person(p4); 

	//注意2：不能利用 拷贝构造函数 初始化匿名对象 编译器认为是对象声明
	//Person p5(p4);

如果用户提供有参构造，编译器不会提供默认构造，会提供拷贝构造

	Person p1; //此时如果用户自己没有提供默认构造，会出错
	Person p2(10); //用户提供的有参
	Person p3(p2); //此时如果用户没有提供拷贝构造，编译器会提供

浅拷贝：简单的赋值拷贝操作 ，即=赋值，编译器给的是浅拷贝
深拷贝：在堆区重新申请空间，进行拷贝操作，即new

浅拷贝带来的问题是堆区内存非法（多次）释放，要利用深拷贝解决。

C++类中的成员可以是另一个类的对象，我们称该成员为 对象成员

例如：

class A {}
class B
{
    A a；
}

B类中有对象A作为成员，A为对象成员

构造的顺序是 ：先调用对象成员的构造，再调用本类构造
析构顺序与构造相反

静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员
静态成员不属于某一个对象，属于所有对象共享一份数据
静态成员分为：

• 静态成员变量
  • 所有对象共享同一份数据
  • 在编译阶段分配内存
  • 类内声明，类外初始化
• 静态成员函数
  • 所有对象共享同一个函数
  • 静态成员函数只能访问静态成员变量

进行类外初始化的时候： 要在前面 类名：：

class person
{
public:
    static int m_a;
};
int person::m_a=10;  //发现如果不用这句在类外初始化竟然会报错
int main()
{
    person p1;
    p1.m_a=100;
    cout<<"p1:"<<p1.m_a<<endl;
    person p2;
    p2.m_a=3000;
    cout<<"p2:"<<p2.m_a<<endl;
}

//静态成员函数特点：
//1 程序共享一个函数
//2 静态成员函数只能访问静态成员变量

因为静态函数访问非静态变量时不知道时访问哪个对象的变量

在C++中，类内的成员变量和成员函数分开存储

只有非静态成员变量才属于类的对象上

class Person {
public:
Person() {
mA = 0;
}
//非静态成员变量占对象空间
int mA;
//静态成员变量不占对象空间
static int mB;
//函数也不占对象空间，所有函数共享一个函数实例
void func() {
cout << “mA:” << this->mA << endl;
}
//静态成员函数也不占对象空间
static void sfunc() {
}
};

this指针的用途：

• 当形参和成员变量同名时，可用this指针来区分
• 在类的非静态成员函数中返回对象本身，可使用return *this

class person
{
public:

    person(int age)
    {
        this->age = age;
    }

    person& personadd(const person& p)
    {
        this->age += p.age;
        return *this;
    }

    int age;
};

int main()
{
    person p1(10);
    cout << "p1'age:" <<p1.age << endl;

    person p2(10);
    p2.personadd(p1).personadd(p1);
    cout << "p2'age:" << p2.age << endl;
}

空指针可以访问成员函数，但如果成员函数中含有this指针，就不可以了

const修饰成员函数
常函数：

• 成员函数后加const后我们称为这个函数为常函数
• 常函数内不可以修改成员属性
• 成员属性声明时加关键字mutable后，在常函数中依然可以修改
  常对象：
• 声明对象前加const称该对象为常对象
• 常对象只能调用常函数，因为其它函数可以修改属性

	//this指针的本质是一个指针常量，指针的指向不可修改
	//如果想让指针指向的值也不可以修改，需要声明常函数
	void ShowPerson() const {
		//const Type* const pointer;
		//this = NULL; //不能修改指针的指向 Person* const this;
		//this->mA = 100; //但是this指针指向的对象的数据是可以修改的

		//const修饰成员函数，表示指针指向的内存空间的数据不能修改，除了mutable修饰的变量
		this->m_B = 100;
	}

友元的目的就是让一个函数或者类 访问另一个类中私有成员

友元的三种实现

• 全局函数做友元
• 类做友元
• 成员函数做友元

运算符重载

#include<iostream>
using namespace std;

class person
{
public:
    person() {};
    person(int a, int b)
    {
        this->m_a = a;
        this->m_b = b;
    }

    person operator+(const person& p)
    {
        person temp;
        temp.m_a = this->m_a + p.m_a;
        temp.m_b = this->m_b + p.m_b;
        return temp;
    }

    int m_a;
    int m_b;
};

person operator+(const person& p1, int val)
{
    person temp(0, 0);
    temp.m_a = p1.m_a + val;
    temp.m_b = p1.m_b + val;
    return temp;
}

int main()
{
    person p1(10, 10);
    person p2(12, 12);
    person p3 = p1 + p2;
    cout << "p3:" << p3.m_a << p3.m_b << endl;

    person p4 = p3 + 10;
    cout << "p4:" << p4.m_a << p4.m_b << endl;
}

重载可以发生在成员函数中或者全局函数中
对于内置的数据类型的表达式的的运算符是不可能改变的
不要滥用运算符重载

左移运算符重载:可以输出自定义数据类型，不能输出函数
不会用成员运算符重载左移运算符，因为无法实现cout在左边，
只能用全局函数重载

ostream& operator<<(ostream& out, Person& p) {
	out << "a:" << p.m_A << " b:" << p.m_B;
	return out;
}

重载递增运算符

用占位参数来区分前置递增还是后置递增

父类中私有成员也是被子类继承下去了，只是由编译器给隐藏后访问不到

子类继承父类后，当创建子类对象，也会调用父类的构造函数

继承中 先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反

当子类成员与父类同名时：
调用子类成员直接用函数名，调用父类要加作用域

静态成员和非静态成员出现同名，处理方式一致

C++允许一个类继承多个类
语法：class 子类 ：继承方式 父类1 ， 继承方式 父类2...
多继承可能会引发父类中有同名成员出现，需要加作用域区分
C++实际开发中不建议用多继承

• 菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义
• 利用虚继承可以解决菱形继承问题

多态分为两类

• 静态多态: 函数重载 和 运算符重载属于静态多态，复用函数名
• 动态多态: 派生类和虚函数实现运行时多态
  静态多态和动态多态区别：
• 静态多态的函数地址早绑定 - 编译阶段确定函数地址
• 动态多态的函数地址晚绑定 - 运行阶段确定函数地址

通常说的多态都是动态多态

满足动态多态：

1. 有继承关系
2. 子类重写父类虚函数 （函数返回值类型 函数名，参数列表完全相同）
3. 父指针或引用指向子类对象

当子类重写父类的虚函数，子类中的虚函数表内部会替换成子类的虚函数地址

C++开发提倡利用多态设计程序架构，因为多态优点很多

在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容
因此可以将虚函数改为纯虚函数
纯虚函数语法：virtual 返回值类型 函数名 （参数列表）= 0 ;
当类中有了纯虚函数，这个类也称为抽象类
抽象类特点：

• 无法实例化对象
• 子类必须重写抽象类中的纯虚函数，否则也属于抽象类

class calculator
{
public:
	virtual int result()
	{
		return 0;
	}

	int num1;
	int num2;
};

class add : public calculator
{
	int result()
	{
		return num1 + num2;
	}
};

int main()
{
	calculator* Add = new add();  //父指针或引用指向子类对象
	Add->num1 = 10;
	Add->num2 = 20;
	cout << Add->num1 << "+" << Add->num2 << "=" << Add->result() << endl;
	
}

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码

解决方式：将父类中的析构函数改为虚析构或者纯虚析构
虚析构和纯虚析构共性：

• 可以解决父类指针释放子类对象
• 都需要有具体的函数实现
  虚析构和纯虚析构区别：
• 如果是纯虚析构，该类属于抽象类，无法实例化对象
  虚析构语法：
  virtual ~类名(){}
  纯虚析构语法：
  virtual ~类名() = 0;
类名::~类名(){}