初识c++

C++之父-本贾尼·斯特劳斯特卢普

示例代码

#include <iostream>   //C++标准输入输出流的头文件 等同于C语言stdio.h
using namespace std;   // 为了减少命名冲突

int main(int argc, char const *argv[])
{
	cout << "hello world c++" << endl;

	return 0;
}

作用域控制符

使用作用域访问符::访问全局变量

命名空间

namespace A
{
	int a = 20;
	int b = 30;
}

namespace B
{
	int a = 20;
	int b = 30;
}

匿名空间里的都是内部链接

using 引用声明

结构体Struct

#include <iostream>
using namespace std;

struct Person
{
	string name;
	int age;
	string getname()
	{
		return name;
	}
};

int main(void)
{
	Person p1 = {"小明", 18};
}

C++类型检查更加严格

C++三目运算后返回的是变量

c语言，全局const变量存放在只读数据段
c语言，局部const变量存放在栈区

C++默认支持变长数组

在c++中，一个const不必创建内存空间，而在c中，一个const总是需要一块内存空间

c中const默认是外部链接。c++中const默认是内部链接

C++宏定义不受命名空间的约束

int a = 10;
int& ra = a;

Type& ra = a;

/引用的本质就是一个常指针/ 指针常量
/作用是减少指针的使用/

char*& pp;

#include <iostream>
using namespace std;

void my_free(char*& p)
{
	free(p);
	p = NULL;
}

int main(void)
{
	char* p = (char*)malloc(10);
	my_free(p);
	return 0;
}

struct里的成员函数编译器会默认在前面加inline关键字
inline用在函数定义
类中的成员函数默认都是内联函数（不加inline也是内联函数）
有时候就算加上inline也不一定是内联函数
构成重载的条件：1. 在同一个作用域 2. 函数名相同
main函数是被_start调用的

C++编译器会对程序中的函数做换名，
将参数表中的类型信息汇合到函数名中，以保证函数名的唯一。
通过extern "C"，可以要求编译器不做C++换名，以方便在C语言的模块中使用C++编译生成的代码。

方式一:
extern "C"
{
	int add (int a, int b)
	{
		return a + b;
	}
	int sub (int a,int b)
	{
		return a - b;
	}
}
方式二:
extern "C" int add (int a, int b, int c)
{
	return a + b + c;
}

class里的默认权限是private
struct里的默认权限是public

构造函数是编译器自动调用，作用是初始化实例变量

析构函数

不要用拷贝构造函数初始化匿名对象

初始化列表只用在构造函数中

explicit禁止构造函数隐式转换

delete表达式先调用析构函数，然后释放内存

类对象中只有成员变量占空间，成员函数和静态变量是不占空间的

类的大小也要遵循对齐补齐规则

#pragma pack(1) 改变默认对齐数

结构体里不能使用静态数据成员，因为结构体中的静态数据成员，默认放在只读文本(.text)段

结构体中的静态数据成员和类一样，属于结构体变量之间共享，必须在结构体之外初始化

friend只能出现在声明处（类中）

友元关系不能被继承

友元关系是单向的

友元关系不具有传递性

全局函数运算符重载+

int operator+(Person& p1, Person& p1)
{
	return p1.money + p2.money;
}

ostream类不允许拷贝构造

operator& operator<<(ostream cout, Person p)
{
	cout << p.name << "现在有" << p.name << "块钱"；
	return cout;
}

三元运算符不能重载

2023-09-26 09:28:20 星期二

不能连续后置++

子类继承父类，并不是父类的所有成员都能被子类继承，构造函数，析构函数，赋值运算符都不能被子类继承

纯虚函数的意义就是提供接口

父类的引用/指针，指向子类的对象

class BoiledDrinks
{
public:
	// 煮
	virtual void boil(void)=0;
	// 冲泡
	virtual void brew(void)=0;
	// 搅拌
	virtual void mix(void)=0;
	// 品尝
	virtual void taste(void)=0;

	void enjoy(void)
	{
		boil();
		brew();
		mix();
		taste();
	}
};

class Coffee:public BoiledDrinks
{
public:
	// 煮
	void boil(void)
	{
		cout << "煮咖啡"<< endl;
	}
	// 冲泡
	void brew(void)
	{
		cout << "冲泡咖啡"<< endl;
	}
	// 搅拌
	void mix(void)
	{
		cout << "搅拌咖啡"<< endl;
	}
	// 品尝
	void taste(void)
	{
		cout << "品尝咖啡"<< endl;
	}
};

class Tea:public BoiledDrinks
{
public:
	// 煮
	void boil(void)
	{
		cout << "煮茶"<< endl;
	}
	// 冲泡
	void brew(void)
	{
		cout << "冲泡茶"<< endl;
	}
	// 搅拌
	void mix(void)
	{
		cout << "搅拌茶"<< endl;
	}
	// 品尝
	void taste(void)
	{
		cout << "喝茶"<< endl;
	}
};


void boiledBeverages(BoiledDrinks& ob)
{
	ob.enjoy();
	return;
}


int main(int argc, char const *argv[])
{
	Coffee co;
	Tea t;

	BoiledDrinks& b1 = co;
	BoiledDrinks& b2 = t;

	boiledBeverages(b1);
	cout << "------------------" << endl;
	boiledBeverages(b2);

	return 0;
}

虚析构的作用就是通过父类指针，释放子类的所有空间
纯虚析构函数在类中声明，在类外实现