C++学习笔记

Posted 2021-08-21 OIqng

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了C++学习笔记相关的知识，希望对你有一定的参考价值。

C++学习笔记

参考：
菜鸟教程 w3cschool

C++简介

C++ 是一种静态类型的、编译式的、通用的、大小写敏感的、不规则的编程语言，支持过程化编程、面向对象编程和泛型编程。

C++是Bjarne Stroustrup于20世纪80年代在贝尔实验室开发出的。

C++是在C语言的基础上添加了对面向对象编程和泛型编程的支持的语言。

C语言编程原理

计算机语言的概念——数据和算法。数据是程序使用和处理的信息（好比做红烧肉的用料），算法是程序使用的方法（好比做做红烧肉的步骤）。C语言最初便是过程性（procedural）语言，即强调算法。自顶向下（top-down）的设计，将大型程序分解小型、便于管理的任务。（好比学习英语这件事分解为学音标、发音、背单词、学语法）

面向对象编程

OOP（Object Oriented Programming）强调数据。
在C++中，类是一种规范，即描述这种新型数据结构；对象是根据这种规范构造的特定数据结构。例如：类可以描述学生的基本特征（姓名、年龄、班级、外貌等），而对象则代表特定的学生。
OOP中从类到程序的处理过程叫做自下向上（bottom-up）的编程。OOP编程不仅是将数据和方法合并为类定义。还有创建可重用的代码、为运算符和函数创建多个定义的多态、使用旧类派生出新类的继承。
C++的优点之一：方便地重用和修改现有的、经过测试的代码。

泛型编程

泛型编程（generic programming）强调独立于特定数据类型，它使重用代码和抽象通用概念更加简单，提供了执行常见任务的工具。术语泛型（generic）是指创建独立于类型的代码。

C++基本语法

// #include编译指令，将iostream文件内容添加到程序中，这是一个预处理操作
#include <iostream> 
// using编译指令，名称空间编译指令
using namespace std;
int main()// 
{

	cout << "Hello World!"; // 使用cout输出Hello World！，<<在这里是插入运算符
	cout << endl; // 控制符（manipulator），重起一行
	cout << "I";
	return 0; // 返回语句（return statement）,结束函数
}

这是没有cout << endl;的显示效果

这是有cout << endl;的显示效果，也可使用换行符\\n

C++ 标识符

C++ 标识符是用来标识变量、函数、类、模块，或任何其他用户自定义项目的名称。一个标识符以字母 A-Z 或 a-z 或下划线 _ 开始，后跟零个或多个字母、下划线和数字（0-9）。

C++ 标识符内不允许出现标点字符，比如 @、$ 和 %。C++ 是区分大小写的编程语言。因此，在 C++ 中，Manpower 和 manpower 是两个不同的标识符。

C++注释

//一般用于单行注释。
/* … */ 一般用于多行注释

C++ 修饰符类型

C++ 允许在 char、int 和 double 数据类型前放置修饰符。修饰符用于改变基本类型的含义，所以它更能满足各种情境的需求。

下面列出了数据类型修饰符：

signed
unsigned
long
short

修饰符 signed、unsigned、long 和 short 可应用于整型，signed 和 unsigned 可应用于字符型，long 可应用于双精度型。

修饰符 signed 和 unsigned 也可以作为 long 或 short 修饰符的前缀。例如：unsigned long int。

C++ 允许使用速记符号来声明无符号短整数或无符号长整数。您可以不写 int，只写单词 unsigned short 或 unsigned long，int 是隐含的。例如，下面的两个语句都声明了无符号整型变量。

unsigned x;
unsigned int y;

如：

#include <iostream>
using namespace std;
int main()
{
	short int a; // 有符号短整数
	short unsigned int b; // 无符号短整数
	a = 50000;
	b = a;
	cout << b << endl << a;
	return 0;
}

C++ 中的类型限定符

类型限定符提供了变量的额外信息。

限定符	含义
const	const 类型的对象在程序执行期间不能被修改改变
volatile	修饰符 volatile 告诉编译器，变量的值可能以程序未明确指定的方式被改变
restrict	由 restrict 修饰的指针是唯一一种访问它所指向的对象的方式。只有 C99 增加了新的类型限定符 restrict

C++ 运算符

算术运算符
关系运算符
逻辑运算符
位运算符
赋值运算符
杂项运算符

算术运算符

假设变量 A 的值为 10，变量 B 的值为 5，则：

运算符	描述	实例
`+`	加	A + B 将得到 15
`-`	减	A - B 将得到5
`*`	乘	A * B 将得到 50
`/`	除	A / B 将得到 2
`%`	取余	A % B 将得到 0
`++`	自增运算符，整数值增加 1	A++ 将得到 11
–	自减运算符，整数值减少 1	A-- 将得到 9

关系运算符

假设变量 A 的值为 10，变量 B 的值为 20，则：

运算符	描述	实例
`==`	相等	(A == B) 不为真
`!=`	不相等	(A != B) 为真
`>`	大于	(A > B) 不为真
`<`	小于	(A < B) 为真
`>=`	大于等于	(A >= B) 不为真
`<=`	小于等于	(A <= B) 为真

逻辑运算符

假设变量 A 的值为 1，变量 B 的值为 0，则：

运算符	描述	实例
`&&`	逻辑与运算符	`A && B`
`\|\|`	逻辑或运算符	`A \|\| B`
`!`	逻辑非运算符	`!(A && B)`

位运算符

位运算符作用于位，并逐位执行操作。&、 | 和 ^ 的真值表如下所示：

`a`	`b`	`a & b`	`a\|b`	`a ^ b`
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

赋值运算符

运算符	描述	实例
`=`	赋值运算符	`C = A + B`
`+=`	加且赋值运算符	`C += A` 相当于 `C = C + A`
`-=`	减且赋值运算符	`C -= A` 相当于 `C = C - A`
`*=`	乘且赋值运算符	`C = A` 相当于 `C = C A`
`/=`	除且赋值运算符	`C /= A` 相当于 `C = C / A`
`%=`	求模且赋值运算符	`C %= A` 相当于 `C = C % A`
`<<=`	左移且赋值运算符	`C <<= 2` 等同于 `C = C << 2`
`>>=`	右移且赋值运算符	`C >>= 2` 等同于 `C = C >> 2`
`&=`	按位与且赋值运算符	`C &= 2` 等同于 `C = C & 2`
`^=`	按位异或且赋值运算符	`C ^= 2` 等同于 `C = C ^ 2`
`\|=`	按位或且赋值运算符	`C \|= 2` 等同于 `C = C \| 2`

杂项运算符

运算符	描述
`sizeof`	sizeof 运算符返回变量的大小。
`Condition ? X : Y`	条件运算符
`,`	逗号运算符会顺序执行一系列运算
`.（点）和 ->（箭头）`	成员运算符用于引用类、结构和共用体的成员
`Cast`	强制转换运算符把一种数据类型转换为另一种数据类型
`&`	指针运算符 & 返回变量的地址
`*`	指针运算符 * 指向一个变量

C++ 数据类型

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

一些基本类型可以使用一个或多个类型修饰符进行修饰：

signed
unsigned
short
long

各种变量类型在内存中存储值时需要占用的内存，以及该类型的变量所能存储的最大值和最小值。
注意：不同系统会有所差异。

类型	位	范围
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 个宽字符

输出各种数据类型的大小

#include <iostream>
using namespace std;

int main()
{
	cout << "Size of char : " << sizeof(char) << endl;
	cout << "Size of int : " << sizeof(int) << endl;
	cout << "Size of short int : " << sizeof(short int) << endl;
	cout << "Size of long int : " << sizeof(long int) << endl;
	cout << "Size of float : " << sizeof(float) << endl;
	cout << "Size of double : " << sizeof(double) << endl;
	cout << "Size of wchar_t : " << sizeof(wchar_t) << endl;
	return 0;
}

typedef 声明

typedef 可以为一个已有的类型如int取一个新的名字

typedef type newname;

枚举类型

枚举类型声明一个可选的类型名称和一组标识符，用来作为该类型的值。其带有零个或多个标识符可以被用来作为该类型的值。每个枚举数是一个枚举类型的常数。

创建枚举，需要使用关键字 enum。枚举类型的一般形式为：

enum enum-name { list of names } var-list;

enum-name 是枚举类型的名称，名称列表 { list of names } 中的内容用逗号分隔。

C++ 变量类型

C++变量

类型	描述
bool	存储值 true 或 false
char	通常是一个八位字节（一个字节）
int	整数
float	单精度浮点值
double	双精度浮点值
void	表示类型的缺失
wchar_t	宽字符类型

变量定义

变量定义就是告诉编译器在何处创建变量的存储，以及如何创建变量的存储。变量定义指定一个数据类型，并包含了该类型的一个或多个变量的列表，如下所示：

type variable_list;

#include <iostream>
using namespace std;

int main()
{
	int a = 1 , e = 2;
	char b = 'a', f = 'A';
	float c = 1.2 , g = 2.1;
	double d  = true, h = false;
	cout << a << endl << e << endl;
	cout << b << endl << f << endl;
	cout << c << endl << g << endl;
	cout << d << endl << h << endl;
	return 0;
}

C++连续赋值

	int a;
	int b;
	int c;
	a = b = c = 9;
	cout << a << b << c;

C++ 中的变量声明

变量声明向编译器保证变量以给定的类型和名称存在，这样编译器在不需要知道变量完整细节的情况下也能继续进一步的编译。变量声明只在编译时有它的意义，在程序连接时编译器需要实际的变量声明。

当您使用多个文件且只在其中一个文件中定义变量时（定义变量的文件在程序连接时是可用的），变量声明就显得非常有用。您可以使用 extern 关键字在任何地方声明一个变量。虽然您可以在 C++ 程序中多次声明一个变量，但变量只能在某个文件、函数或代码块中被定义一次。

#include <iostream>
using namespace std;
extern int a, b; // 变量声明
int main()
{
	int a, b; // 变量定义
	a = 10; // 初始化
	b = 20;
	cout << a << b;
	return 0;
}

C++ 中的左值（Lvalues）和右值（Rvalues）

左值（lvalue）：指向内存位置的表达式被称为左值（lvalue）表达式。左值可以出现在赋值号的左边或右边。
右值（rvalue）：术语右值（rvalue）指的是存储在内存中某些地址的数值。右值是不能对其进行赋值的表达式，也就是说，右值可以出现在赋值号的右边，但不能出现在赋值号的左边。
如：int a = 10；

C++ 变量作用域

局部变量，在函数或一个代码块内部声明的变量

#include <iostream>
	using namespace std;
	
	int main()
	{
		int a, b, c;
		a = 10;
		b = 20;
		c = a + b;
		cout << c;
		return 0;
	}

形式参数，在函数参数的定义中声明的变量
全局变量，在所有函数外部声明的变量

#include <iostream>
using namespace std;
int d;
int main()
{
	int a, b;
	a = 10;
	b = 20;
	d = a + b;
	cout << d;
	return 0;
}

以上局部变量和全局变量的运行结果都是30

初始化局部变量和全局变量

定义全局变量时，系统会自动初始化为下列值：

数据类型	初始化默认值
int	0
char	‘\\0’
float	0
double	0
pointer	NULL

C++ 常量

常量是一个固定值，即在程执行期间不会改变，又叫做字面量。
常量可以是任何的基本数据类型，可分为整型数字、浮点数字、字符、字符串和布尔值。
常量的值在定义后不能进行修改。

整数常量

整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数：0x 或 0X 表示十六进制，0 表示八进制，不带前缀则默认表示十进制。

整数常量也可以带一个后缀，后缀是 U 和 L 的组合，U 表示无符号整数（unsigned），L 表示长整数（long）。后缀可以是大写，也可以是小写，U 和 L 的顺序任意。
如：

58         // 十进制
0245       // 八进制 
0x2b       // 十六进制 
20         // 整数 
20u        // 无符号整数 
45l        // 长整数 
60ul       // 无符号长整数

浮点常量

浮点常量由整数部分、小数点、小数部分和指数部分组成。您可以使用小数形式或者指数形式来表示浮点常量。

当使用小数形式表示时，必须包含小数点、指数，或同时包含两者。当使用指数形式表示时，必须包含整数部分、小数部分，或同时包含两者。带符号的指数是用 e 或 E 引入的。

3.14159       // 合法的 
314159E-5L    // 合法的 
520E          // 非法的：不完整的指数
1314f          // 非法的：没有小数或指数
.e55          // 非法的：缺少整数或分数

布尔常量

true 值代表真。
false 值代表假。

字符常量
字符常量是括在单引号中。如果常量以 L（仅当大写时）开头，则表示它是一个宽字符常量（例如 L’x’），此时它必须存储在 wchar_t 类型的变量中。否则，它就是一个窄字符常量（例如 ‘x’），此时它可以存储在 char 类型的简单变量中。

字符常量可以是一个普通的字符（例如 ‘x’）、一个转义序列（例如 ‘\\t’），或一个通用的字符（例如 ‘\\u02C0’）。

在 C++ 中，有一些特定的字符，当它们前面有反斜杠时，它们就具有特殊的含义，被用来表示如换行符（\\n）或制表符（\\t）等。下表列出了一些这样的转义序列码：

转义序列	含义
\\\\	\\ 字符
\\’	’ 字符
\\"	" 字符
\\?	? 字符
\\a	警报铃声
\\b	退格键
\\f	换页符
\\n	换行符
\\r	回车
\\t	水平制表符
\\v	垂直制表符
\\ooo	一到三位的八进制数
\\xhh . . .	一个或多个数字的十六进制数

字符串常量

字符串字面值或常量是括在双引号 “” 中的。一个字符串包含类似于字符常量的字符：普通的字符、转义序列和通用的字符。

定义常量

使用 #define 预处理器。
使用 const 关键字。

#define 预处理器

使用 #define 预处理器定义常量的形式：

#define identifier value

如：

#include <iostream>
using namespace std;
#define PI 3.14
int main()
{
	int r = 5;
	float area;
	area = r * r * PI;
	cout << area;
	return 0;
}

const 关键字

使用 const 前缀声明指定类型的常量，如下所示：

const type variable = value;

如：

#include <iostream>
using namespace std;
int main()
{
	const float PI = 3.14;
	int r = 5;
	float area;
	area = r * r * PI;
	cout << area;
	return 0;
}

C++ 循环

循环语句允许我们多次执行一个语句或语句组

C++ while 循环

C++ 中 while 循环的语法：

while(condition)
{
   statement(s);
}

statement(s) 可以是一个单独的语句，也可以是几个语句组成的代码块。condition 可以是任意的表达式，当为任意非零值时都为真。当条件为真时执行循环。
如：

#include <iostream>
using namespace std;
int main()
{
	int a = 1;
	while (a < 10)
	{
		cout << a << endl;
		a++;
	}
	return 0;
}

C++ for 循环

for 循环允许编写一个执行特定次数的循环的重复控制结构
C++ 中 for 循环的语法：

for ( init; condition; increment )
{
   statement(s);
}

如：

#include <iostream>
using namespace std;
int main()
{
	for (int a = 1; a < 10; a = a + 1)
	{
		cout << a << endl;
	}
	return 0;
}

C++ do…while 循环

do…while 循环是在循环的尾部检查它的条件,即会确保至少执行一次循环。

C++ 中 do…while 循环的语法：

do
{
   statement(s);

}while( condition );

如：

#include <iostream>
using namespace std;
int main()
{
	int a = 1;
	do
	{
		cout << a << endl;
		a = a + 1;
	} while (a < 10);
	return 0;
}

C++ 嵌套循环

一个循环内可以嵌套另一个循环

C++ 中嵌套 for 循环语句的语法：

for ( init; condition; increment )
{
   for ( init; condition; increment )
   {
      statement(s);
   }
   statement(s); 
}

C++ 中嵌套 while 循环语句的语法：

while(condition)
{
   while(condition)
   {
      statement(s);
   }
   statement(s); /
}

C++ 中嵌套 do…while 循环语句的语法：

do
{
   statement(s); 
   do
   {
      statement(s);
   }while( condition );

}while( condition );

C++ break 语句

当 break 语句出现在一个循环内时，循环会立即终止，且程序流将继续执行紧接着循环的下一条语句。

break 语句可用于终止 switch 语句中的一个 case。

C++ 中 break 语句的语法：

break;

如：

#include <iostream>
using namespace std;
int main()
{
	int a = 1;
	do
	{
		cout << a << endl;
		a = a + 1;
		if (a == 5)
		{
			break;
		}
	} while (a < 10);
	return 0;
}

C++ continue 语句

continue 会跳过当前循环中的代码，强迫开始下一次循环。

C++ 中 continue 语句的语法：

continue;

#include <iostream>
using namespace std;
int main()
{
	int a = 1;
	do
	{
		cout << a << endl;
		a = a + 1;
		if (a == 5)
		{
			a = a + 1;
			continue;
		}
	} while (a < 10);
	return 0;
}

C++ goto 语句

goto 语句允许把控制无条件转移到同一函数内的被标记的语句。

C++ 中 goto 语句的语法：

goto label;
..
.
label: statement;

C++ 判断

判断结构要求指定一个或多条件为真时要执行的语句和条件为假时要执行的语句。

C++ if 语句

C++ 中 if 语句的语法：

if(boolean_expression)
{
   // 如果布尔表达式为真将执行的语句
}

C++ if…else 语句

一个 if 语句后可跟一个可选的 else 语句，else 语句在布尔表达式为假时执行。

C++ 中 if…else 语句的语法：

if(boolean_expression)
{
   // 如果布尔表达式为真将执行的语句
}
else
{
   // 如果布尔表达式为假将执行的语句
}

if…else if…else 语句

一个 if 语句后可跟一个可选的 else if…else 语句，这可用于测试多种条件。

当使用 if…else if…else 语句时，以下几点需要注意：

一个 if 后可跟零个或一个 else，else 必须在所有 else if 之后。
一个 if 后可跟零个或多个 else if，else if 必须在 else 之前。
一旦某个 else if 匹配成功，其他的 else if 或 else 将不会被测试。

C++ 中的 if…else if…else 语句的语法：

if(boolean_expression 1)
{
   // 当布尔表达式 1 为真时执行
}
else if( boolean_expression 2)
{
   // 当布尔表达式 2 为真时执行
}
else if( boolean_expression 3)
{
   // 当布尔表达式 3 为真时执行
}
else 
{
   // 当上面条件都不为真时执行
}

C++ 嵌套 if 语句

C++ 中嵌套 if 语句的语法：

if( boolean_expression 1)
{
   // 当布尔表达式 1 为真时执行
   if(boolean_expression 2)
   {
      // 当布尔表达式 2 为真时执行
   }
}

C++ switch 语句

一个 switch 语句允许测试一个变量等于多个值时的情况。每个值称为一个 case，且被测试的变量会对每个 switch case 进行检查。

C++ 中 switch 语句的语法：

switch(expression){
    case constant-expression  :
       statement(s);
       break; // 可选的
    case constant-expression  :
       statement(s);
       break; // 可选的
  
    // 您可以有任意数量的 case 语句
    default : // 可选的
       statement(s);
}

switch 语句必须遵循下面的规则：

switch 语句中的 expression 必须是一个整型或枚举类型，或者是一个 class 类型，其中 class
有一个单一的转换函数将其转换为整型或枚举类型。
在一个 switch 中可以有任意数量的 case 语句。每个 case 后跟一个要比较的值和一个冒号。
case 的 constant-expression 必须与 switch 中的变量具有相同的数据类型，且必须是一个常量或字面量。
当被测试的变量等于 case 中的常量时，case 后跟的语句将被执行，直到遇到 break 语句为止。
当遇到 break 语句时，switch 终止，控制流将跳转到 switch 语句后的下一行。
不是每一个 case 都需要包含 break。如果 case 语句不包含 break，控制流将会继续后续的 case&
以上是关于C++学习笔记的主要内容，如果未能解决你的问题，请参考以下文章

《C++ Primer Plus》学习笔记——C++程序创建到运行的整个过程

C++ 学习笔记

C++ 解释器/控制台/片段编译器

C++代码调试的学习笔记

C++学习笔记1

C++异常处理的学习笔记