2023年的C++基础笔记

C++ 基本语法

对象 - 对象具有状态和行为。例如：一只狗的状态 - 颜色、名称、品种，行为 - 摇动、叫唤、吃。对象是类的实例。

类 - 类可以定义为描述对象行为/状态的模板/蓝图。

方法 - 从基本上说，一个方法表示一种行为。一个类可以包含多个方法。可以在方法中写入逻辑、操作数据以及执行所有的动作。

即时变量 - 每个对象都有其独特的即时变量。对象的状态是由这些即时变量的值创建的。

C++ 关键字

下表列出了 C++ 中的保留字。这些保留字不能作为常量名、变量名或其他标识符名称。

asm	else	new	this
auto	enum	operator	throw
bool	explicit	private	true
break	export	protected	try
case	extern	public	typedef
catch	false	register	typeid
char	float	reinterpret_cast	typename
class	for	return	union
const	friend	short	unsigned
const_cast	goto	signed	using
continue	if	sizeof	virtual
default	inline	static	void
delete	int	static_cast	volatile
do	long	struct	wchar_t
double	mutable	switch	while
dynamic_cast	namespace	template

1. asm

asm (指令字符串)：允许在 C++ 程序中嵌入汇编代码。

2. auto

auto（自动，automatic）是存储类型标识符，表明变量"自动"具有本地范围，块范围的变量声明（如for循环体内的变量声明）默认为auto存储类型。

3. bool

bool（布尔）类型，C++ 中的基本数据结构，其值可选为 true（真）或者 false（假）。C++ 中的 bool 类型可以和 int 混用，具体来说就是 0 代表 false，非 0 代表 true。bool 类型常用于条件判断和函数返回值。

4. break

break（中断、跳出），用在switch语句或者循环语句中。程序遇到 break 后，即跳过该程序段，继续后面的语句执行。

5. case

用于 switch 语句中，用于判断不同的条件类型。

6. catch

catch 和 try 语句一起用于异常处理。

7. char

char（字符，character）类型，C++ 中的基本数据结构，其值一般为 0~255 的 int。这 256 个字符对应着 256 个 ASCII 码。char 类型的数据需要用单引号 ' 括起来。

8.class

class（类）是 C++ 面向对象设计的基础。使用 class 关键字声明一个类。

9. const

const（常量的，constant）所修饰的对象或变量不能被改变，修饰函数时，该函数不能改变在该函数外面声明的变量也不能调用任何非const函数。在函数的声明与定义时都要加上const，放在函数参数列表的最后一个括号后。在 C++ 中，用 const 声明一个变量，意味着该变量就是一个带类型的常量，可以代替 #define，且比 #define 多一个类型信息，且它执行内链接，可放在头文件中声明；但在 C 中，其声明则必须放在源文件（即 .C 文件）中，在 C 中 const 声明一个变量，除了不能改变其值外，它仍是一具变量。

const double pi(3.14159);
 const double pi = 3.14159;

10. const_cast常量转换

常量转换用于将 const 类型的对象转换为非 const 类型的对象。
常量转换只能用于转换掉 const 属性，不能改变对象的类型。

const_cast (expression)

该运算符用来修改类型的 const 或 volatile 属性。除了 const 或 volatile 修饰之外， type_id 和 expression 的类型是一样的。常量指针被转化成非常量指针，并且仍然指向原来的对象；常量引用被转换成非常量引用，并且仍然指向原来的对象；常量对象被转换成非常量对象。

11. continue

continue（继续）关键字用于循环结构。它使程序跳过代码段后部的部分，与 break 不同的是，continue 不是进入代码段后的部分执行，而是重新开始新的循环。因而它是"继续循环"之意，不是 break（跳出）。

12. default

default（默认、缺省）用于 switch 语句。当 switch 所有的 case 都不满足时，将进入 default 执行。default 只能放在 switch 语句所有的 case 之后，并且是可选的。

13. delete

delete（删除）释放程序动态申请的内存空间。delete 后面通常是一个指针或者数组 []，并且只能 delete 通过 new 关键字申请的指针，否则会发生段错误。

14. do

do-while是一类循环结构。与while循环不同，do-while循环保证至少要进入循环体一次。

15. double

double（双精度）类型，C++ 中的基本数据结构，以双精度形式存储一个浮点数。

16. dynamic_cast

dynamic_cast（动态转换），允许在运行时刻进行类型转换，从而使程序能够在一个类层次结构安全地转换类型。dynamic_cast 提供了两种转换方式，把基类指针转换成派生类指针，或者把指向基类的左值转换成派生类的引用。

18. enum

enum（枚举）类型，给出一系列固定的值，只能在这里面进行选择一个。

由用户定义的若干枚举常量的集合。

如果一个变量只有几种可能的值，可以定义为枚举(enumeration)类型。所谓"枚举"是指将变量的值一一列举出来，变量的值只能在列举出来的值的范围内。

enum 枚举名{
     标识符[=整型常数],
     标识符[=整型常数],
...
    标识符[=整型常数]
} 枚举变量;
    

如果枚举没有初始化, 即省掉"=整型常数"时, 则从第一个标识符开始。

enum color { red, green, blue } c;
c = blue;

默认情况下，第一个名称的值为 0，第二个名称的值为 1，第三个名称的值为 2，以此类推。但是，您也可以给名称赋予一个特殊的值，只需要添加一个初始值即可。例如，在下面的枚举中，green 的值为 5。

//blue 的值为 6，因为默认情况下，每个名称都会比它前面一个名称大 1，但 red 的值依然为 0。

enum color { red, green=5, blue };

19. explicit

explicit（显式的）的作用是"禁止单参数构造函数"被用于自动型别转换，其中比较典型的例子就是容器类型。在这种类型的构造函数中你可以将初始长度作为参数传递给构造函数。

20. export

为了访问其他编译单元（如另一代码文件）中的变量或对象，对普通类型（包括基本数据类、结构和类），可以利用关键字 extern，来使用这些变量或对象时；但是对模板类型，则必须在定义这些模板类对象和模板函数时，使用标准 C++ 新增加的关键字 export（导出）。

21. extern

extern（外部的）声明变量或函数为外部链接，即该变量或函数名在其它文件中可见。被其修饰的变量（外部变量）是静态分配空间的，即程序开始时分配，结束时释放。用其声明的变量或函数应该在别的文件或同一文件的其它地方定义（实现）。在文件内声明一个变量或函数默认为可被外部使用。在 C++ 中，还可用来指定使用另一语言进行链接，这时需要与特定的转换符一起使用。目前仅支持 C 转换标记，来支持 C 编译器链接。使用这种情况有两种形式：

extern "C" 声明语句

extern "C" { 声明语句块 }

22. false=0

false（假的），C++ 的基本数据结构 bool 类型的值之一。等同于 int 的 0 值。

23. float

float（浮点数），C++ 中的基本数据结构，精度小于 double。

25. friend

friend（友元）声明友元关系。友元可以访问与其有 friend 关系的类中的 private/protected 成员，通过友元直接访问类中的 private/protected 成员的主要目的是提高效率。友元包括友元函数和友元类。

26. goto

goto（转到），用于无条件跳转到某一标号处开始执行。

28. inline

inline（内联）函数的定义将在编译时在调用处展开。inline 函数一般由短小的语句组成，可以提高程序效率。

29. int

int（整型，integer），C++ 中的基本数据结构，用于表示整数，精度小于 long。

30. long

long（长整型，long integer），C++ 中的基本数据结构，用于表示长整数。

32. namespace

namespace（命名空间）用于在逻辑上组织类，是一种比类大的结构。

33. new

new（新建）用于新建一个对象。new 运算符总是返回一个指针。由 new 创建

34. operator

operator（操作符）用于操作符重载。这是 C++ 中的一种特殊的函数。

38.register

register（寄存器）声明的变量称着寄存器变量，在可能的情况下会直接存放在机器的寄存器中；但对 32 位编译器不起作用，当 global optimizations（全局优化）开的时候，它会做出选择是否放在自己的寄存器中；不过其它与 register 关键字有关的其它符号都对32位编译器有效。

39. reinterpret_cast

 reinpreter_cast (expression)

type-id 必须是一个指针、引用、算术类型、函数指针或者成员指针。它可以把一个指针转换成一个整数，也可以把一个整数转换成一个指针（先把一个指针转换成一个整数，在把该整数转换成原类型的指针，还可以得到原先的指针值）。

41. short

short（短整型，short integer），C++ 中的基本数据结构，用于表示整数，精度小于 int。

42. signed

signed（有符号），表明该类型是有符号数，和 unsigned 相反。数字类型（整型和浮点型）都可以用 signed 修饰。但默认就是 signed，所以一般不会显式使用。

43. sizeof

由于 C++ 每种类型的大小都是由编译器自行决定的，为了增加可移植性，可以用 sizeof 运算符获得该数据类型占用的字节数。

44. static

static（静态的）静态变量作用范围在一个文件内，程序开始时分配空间，结束时释放空间，默认初始化为 0，使用时可改变其值。静态变量或静态函数，只有本文件内的代码才可访问它，它的名字（变量名或函数名）在其它文件中不可见。因此也称为"文件作用域"。在 C++ 类的成员变量被声明为 static（称为静态成员变量），意味着它被该类的所有实例所共享，也就是说当某个类的实例修改了该静态成员变量，其修改值为该类的其它所有实例所见；而类的静态成员函数也只能访问静态成员（变量或函数）。类的静态成员变量必须在声明它的文件范围内进行初始化才能使用，private 类型的也不例外。

45. static_cast静态转换

静态转换是将一种数据类型的值强制转换为另一种数据类型的值。
静态转换不进行任何运行时类型检查，因此可能会导致运行时错误。 

static_cast < type-id > ( expression )

 int i = 10;
 float f = static_cast(i); // 静态将int类型转换为float类型

该运算符把 expression 转换为 type-id 类型，但没有运行时类型检查来保证转换的安全性。它主要有如下几种用法：

• ① 用于类层次结构中基类和子类之间指针或引用的转换。进行上行转换（把子类的指针或引用转换成基类表示）是安全的；进行下行转换（把基类指针或引用转换成子类表示）时，由于没有动态类型检查，所以是不安全的。
• ② 用于基本数据类型之间的转换，如把 int 转换成 char，把 int 转换成 enum。这种转换的安全性也要开发人员来保证。
• ③ 把空指针转换成目标类型的空指针。
• ④ 把任何类型的表达式转换成void类?

注意 static_cast 不能转换掉 expression 的 const、volitale、或者 __unaligned 属性。

46. struct

struct（结构）类型，类似于 class 关键字，与 C 语言兼容（class 关键字是不与 C 语言兼容的），可以实现面向对象程序设计。

48. template

template（模板），C++ 中泛型机制的实现。

49. this

this 返回调用者本身的指针。

50. throw

throw（抛出）用于实现 C++ 的异常处理机制，可以通过 throw 关键字"抛出"一个异常。

51. true!=0

true（真的），C++ 的基本数据结构 bool 类型的值之一。等同于 int 的非 0 值。

53. typedef声明

typedef（类型定义，type define），您可以使用 typedef 为一个已有的类型取一个新的名字。

 typedef 类型 定义名;

typedef type newname;

typedef int feet;  //feet 是 int 的另一个名称别名

feet distance;  //为别名声明一个变量distance

类型说明定义了一个数据类型的新名字而不是定义一种新的数据类型。定义名表示这个类型的新名字。

54. typeid

指出指针或引用指向的对象的实际派生类型。

55. typename

typename（类型名字）关键字告诉编译器把一个特殊的名字解释成一个类型。在下列情况下必须对一个 name 使用 typename 关键字：

• 1． 一个唯一的name（可以作为类型理解），它嵌套在另一个类型中的。
• 2． 依赖于一个模板参数，就是说：模板参数在某种程度上包含这个name。当模板参数使编译器在指认一个类型时产生了误解.

56. union

union（联合），类似于 enum。不同的是 enum 实质上是 int 类型的，而 union 可以用于所有类型，并且其占用空间是随着实际类型大小变化的。

57. unsigned

unsigned（无符号），表明该类型是无符号数，和 signed 相反。

58. using

表明使用 namespace。

59. virtual

virtual（虚的），C++ 中用来实现多态机制。

60. void

void（空的），可以作为函数返回值，表明不返回任何数据；可以作为参数，表明没有参数传入（C++中不是必须的）；可以作为指针使用。

61. volatile

volatile（不稳定的）限定一个对象可被外部进程（操作系统、硬件或并发线程等）改变，声明时的语法如下：

int volatile nVint;

这样的声明是不能达到最高效的，因为它们的值随时会改变，系统在需要时会经常读写这个对象的值。因此常用于像中断处理程序之类的异步进程进行内存单元访问。

C++ 数据类型

使用编程语言进行编程时，需要用到各种变量来存储各种信息。变量保留的是它所存储的值的内存位置。这意味着，当您创建一个变量时，就会在内存中保留一些空间。

您可能需要存储各种数据类型（比如字符型、宽字符型、整型、浮点型、双浮点型、布尔型等）的信息，操作系统会根据变量的数据类型，来分配内存和决定在保留内存中存储什么。

基本的内置类型

类型	关键字
布尔型	bool
字符型	char
整型	int
浮点型	float
双浮点型	double
无类型	void
宽字符型	wchar_t

 一些基本类型可以使用一个或多个其他类型(signed unsigned short long )修饰符进行修饰：

 注意：不同系统会有所差异，一字节为 8 位。

默认情况下，int、short、long都是默认带signed符号

从上表可得知，变量的大小会根据编译器和所使用的电脑而有所不同。

下面实例会输出您电脑上各种数据类型的大小。

sizeof() 运算符用来获取各种数据类型的大小。

类型	位	范围
char	1 个字节	-128 到 127 或者 0 到 255
unsigned char	1 个字节	0 到 255
signed char	1 个字节	-128 到 127
int	4 个字节	-2147483648 到 2147483647
unsigned int	4 个字节	0 到 4294967295
signed int	4 个字节	-2147483648 到 2147483647
short int	2 个字节	-32768 到 32767
unsigned short int	2 个字节	0 到 65,535
signed short int	2 个字节	-32768 到 32767
long int	8 个字节	-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
signed long int	8 个字节	-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
unsigned long int	8 个字节	0 到 18,446,744,073,709,551,615
float	4 个字节	精度型占4个字节（32位）内存空间，+/- 3.4e +/- 38 (~7 个数字)
double	8 个字节	双精度型占8 个字节（64位）内存空间，+/- 1.7e +/- 308 (~15 个数字)
long double	16 个字节	长双精度型 16 个字节（128位）内存空间，可提供18-19位有效数字。
wchar_t	2 或 4 个字节	1 个宽字符

类型转换 

C++ 中有四种类型转换：静态转换(static_cast)、动态转换、常量转换(const_cast)和重新解释转换。

C++ 引用(重要)

引用变量是一个别名，也就是说，它是某个已存在变量的另一个名字。一旦把引用初始化为某个变量，就可以使用该引用名称或变量名称来指向变量。

C++ 引用 vs 指针

引用很容易与指针混淆，它们之间有三个主要的不同：

• 不存在空引用。引用必须连接到一块合法的内存。
• 一旦引用被初始化为一个对象，就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。
• 引用必须在创建时被初始化。指针可以在任何时间被初始化。

C++ 中创建引用

& 读作引用

试想变量名称是变量附属在内存位置中的标签，您可以把引用当成是变量附属在内存位置中的第二个标签。因此，您可以通过原始变量名称或引用来访问变量的内容。例如：

//声明int类型变量i,初始化为17
  int i = 17;
//为 i 声明引用变量r    "r 是一个初始化为 i 的整型引用"
int&  r = i;
//  "s 是一个初始化为 d 的 double 型引用"
double& s = d;

1.原变量值  引用变量值一样  他们的内存地址指针也一样

#include 

using namespace std;

int main ()
{
    // 声明简单的变量
    int    i;
    // 声明引用变量
    int& r = i;
    i = 5;
    cout << "i=" << i << endl; //i=5
    cout << "r=" << r  << endl; //r=5

    double d;
    double& s = d;
    d = 11.7;
    cout << "d=" << d << endl; //d=11.7
    cout << "s=" << s  << endl; // s=11.7

    return 0;
}

#include 
using namespace std;
/**
  引用的原理 &与  不会改变变量的内存指针地址 变量的数值可能会改变
  */
int mainT5() {
    // 引用&   
    // todo 第一部分，不采用 引用 &  n1 n2的数值一样  但是他们的内存地址不一样
    int n1 = 999;
    int n2 = n1;
    cout << "n1值=" << n1 << "  ---  n2值=" << n2 << endl;  //n1值=999  ---  n2值=999
    cout << "n1内存地址=" << &n1 << "--- n2内存地址=" << &n2 << endl; //n1内存地址=0x61fefc--- n2内存地址=0x61fef8

    // todo 第二部分，采用引用 &   n3  n4 的数值一样   他们的内存地址一样
    int n3 =1000;
    int & n4 = n3;
    cout << "n3值=" << n3 << "  ---  n4值=" << n4 << endl; // n3值=1000  ---  n4值=1000
    cout << "n3内存地址=" << &n3 << "--- n4内存地址=" << &n4 << endl; // n3内存地址=0x61fef0--- n4内存地址=0x61fef0
    n4 = 777;
    cout << "再次输出 n3值=" << n3 << "  ---  n4值=" << n4 << endl; // 再次输出 n3值=777  ---  n4值=777
    cout << "再次输出 n3内存地址=" << &n3 << "--- n4内存地址=" << &n4 << endl; // 再次输出 n3内存地址=0x61fef0--- n4内存地址=0x61fef0

    int &  n9 = n3;
    n9 = 9527;
    cout << "再再次输出 n3值=" << n3 << "  ---  n4值=" << n4 << endl; // 再再次输出 n3值=9527  ---  n4值=9527
    cout << "再再次输出 n3内存地址=" << &n3 << "--- n4内存地址=" << &n4 << endl;//再再次输出 n3内存地址=0x61feec--- n4内存地址=0x61feec

    return 0;
}

2. 把引用作为参数   7T5

 C++ 支持把引用作为参数传给函数，这比传一般的参数更安全。

#include 
using namespace std;

void numberChange(int number1, int number2) {
   int temp;
   temp=number1;
   number1=number2;
   number2=temp;
}

// 接收number1number2的地址&number1=pInt1, &number2=pInt2   ，取改指针地址的值，来完成数值的互换
void numberChange2(int*  pInt1, int*  pInt2) {
 int  temp=0;
 temp=*pInt1;
 *pInt1=*pInt2;
 *pInt2=temp;
}

//  & 表示引用  int& x = number1    int& y =number2
//形参x 和  实参number1的内存指针地址一样的    形参y 和  实参number2的内存指针地址一样的
void numberChange3(int& x, int& y) {
  int temp=0;
  temp=x;
  x=y;
  y=temp;
}

/**
  引用的原理 &与  不会改变变量的内存指针地址 变量的数值可能会改变
  */
int main() {
    // 引用&
    // todo 第一部分，不采用 引用 &  n1 n2的数值一样  但是他们的内存地址不一样
    int n1 = 999;
    int n2 = n1;
    cout << "n1值=" << n1 << "  ---  n2值=" << n2 << endl;  //n1值=999  ---  n2值=999
    cout << "n1内存地址=" << &n1 << "--- n2内存地址=" << &n2 << endl; //n1内存地址=0x61fefc--- n2内存地址=0x61fef8

    // todo 第二部分，采用引用 &   n3  n4 的数值一样   他们的内存地址一样
    int n3 =1000;
    int & n4 = n3;
    cout << "n3值=" << n3 << "  ---  n4值=" << n4 << endl; // n3值=1000  ---  n4值=1000
    cout << "n3内存地址=" << &n3 << "--- n4内存地址=" << &n4 << endl; // n3内存地址=0x61fef0--- n4内存地址=0x61fef0
    n4 = 777;
    cout << "再次输出 n3值=" << n3 << "  ---  n4值=" << n4 << endl; // 再次输出 n3值=777  ---  n4值=777
    cout << "再次输出 n3内存地址=" << &n3 << "--- n4内存地址=" << &n4 << endl; // 再次输出 n3内存地址=0x61fef0--- n4内存地址=0x61fef0

    int &  n9 = n3;
    n9 = 9527;
    cout << "再再次输出 n3值=" << n3 << "  ---  n4值=" << n4 << endl; // 再再次输出 n3值=9527  ---  n4值=9527
    cout << "再再次输出 n3内存地址=" << &n3 << "--- n4内存地址=" << &n4 << endl;//再再次输出 n3内存地址=0x61feec--- n4内存地址=0x61feec


    int number1 = 10;
    int number2 = 20;
    //C C++ 如果把变量  number1  number2 直接传递给被调用函数numberChange(number1,number2) 是无法改变主函数传递的参数number1  number2的结果值的
    numberChange(number1,number2);
    cout << "number1= " << number1 << "   number2=" << number2 <
#include 
using namespace std;

double vals[] = {10.1, 12.6, 33.1, 24.1, 50.0};

double&  setValues(int i) {
    double& ref = vals[i];
    return ref;   // 返回第 i 个元素的引用，ref 是一个引用变量，ref 引用 vals[i]
}



int main(){

   // 把引用作为函数的返回值
    for(int i=0;i<5;i++){
        cout << "输出数组vals改变前的元素值vals[" << i << "] = "<