- 指数形式(即浮点形式)
作用：字符型变量用于显示单个字符
语法：char ch = 'a';
注意1：在显示字符型变量时，用单引号将字符括起来，不要用双引号
注意2：单引号内只能有一个字符，不可以是字符串
-
C和C++中字符型变量只占用1个字节。
-
字符常量只能包括一个字符，如
′AB′是不合法的 -
字符常量区分大小写字母，如
′A′和′a′是两个不同的字符常量 -
字符型变量并不是把字符本身放到内存中存储，而是将对应的ASCII编码放入到存储单元
作用：用于表示一串字符
两种风格
- C风格字符串：
char 变量名[] = "字符串值"
char str1[] = “hello world”;
注意：C风格的字符串要用双引号括起来
- C++风格字符串：
string 变量名 = "字符串值"
string str = “hello world”;
注意：C++风格字符串，需要加入头文件==#include==
字符串常量为双引号
常考：字符串 "abc" 在内存中占几个字节？
答：占4个字节，而不是3个字节，编译系统会在字符串最后自动加一个′＼0′作为字符串结束标志。但′＼0′并不是字符串的一部分，它只作为字符串的结束标志
常考: 字符串常量″abc＼n″包含几个字符?
答：不是5个而是4个字符，其中“＼n”是一个转义字符,但它在内存中占5个字节
作用：布尔数据类型代表真或假的值
bool类型只有两个值：
-
true — 真（本质是1）
-
false — 假（本质是0）
bool类型占1个字节大小
关键字：cin、cout
语法： cin >> 变量1>>变量2>>....>>变量n、cout<<表达式1<<表达式2<<...<<表达式n
cout<<a,b,c; //错误，不能一次插入多项
cout<<a+b+c; //正确，这是一个表达式，作为一项
cin>>a>>b>>c>>d;
-
C++规定标识符只能由字母、数字和下划线3种字符组成，且第一个字符必须为字母或下划线
-
不能是关键字
-
区分大小写
-
在一个函数内部定义的变量是局部变量，它只在本函数范围内有效，也就是说只有在本函数内才能使用它们，在此函数以外是不能使用这些变量的
-
形参也是局部变量
- 在函数之外定义的变量是外部变量，称为全局变量
=======================================================================
| 运算符 | 术语 | 示例 | 结果 |
| — | — | — | — |
| + | 正号 | +3 | 3 |
| - | 负号 | -3 | -3 |
| + | 加 | 10 + 5 | 15 |
| - | 减 | 10 - 5 | 5 |
| * | 乘 | 10 * 5 | 50 |
| / | 除 | 10 / 5 | 2 |
| % | 取模(取余) | 10 % 3 | 1 |
| ++ | 前置递增 | a=2; b=++a; | a=3; b=3; |
| ++ | 后置递增 | a=2; b=a++; | a=3; b=2; |
| – | 前置递减 | a=2; b=–a; | a=1; b=1; |
| – | 后置递减 | a=2; b=a–; | a=1; b=2; |
注意：
-
两个整数相除结果依然是整数（这里不进行四舍五入，直接舍去小数点后面数字）
-
C++中两个小数可以相除
-
运算的两个数中有一个数为float型数据，则运算的结果是double型，因为C++在运算时对所有float型数据都按double型数据处理
-
只有整型变量可以进行取模运算，两个小数不可以取模
-
在除法运算中，除数不能为0
-
取模运算时，除数也不能为0
常考：
-
前置后置运算符单独使用没有什么区别
-
前置递增先对变量进行++，再计算表达式
-
后置递增先计算表达式，后对变量进行++
-
请详细看下方代码并理解
//递增
int main() {
//后置递增
int a = 10;
a++; //等价于a = a + 1
cout << a << endl; // 11
//前置递增
int b = 10;
++b;
cout << b << endl; // 11
//区别
//前置递增先对变量进行++，再计算表达式
int a2 = 10;
int b2 = ++a2 * 10;
cout << b2 << endl; //110
//后置递增先计算表达式，后对变量进行++
int a3 = 10;
int b3 = a3++ * 10;
cout << b3 << endl; //100
system(“pause”);
return 0;
}
作用：用于将表达式的值赋给变量
- 请详细看表格即可
| 运算符 | 术语 | 示例 | 结果 |
| — | — | — | — |
| = | 赋值 | a=2; b=3; | a=2; b=3; |
| += | 加等于 | a=0; a+=2; | a=2; |
| -= | 减等于 | a=5; a-=3; | a=2; |
| *= | 乘等于 | a=2; a*=2; | a=4; |
| /= | 除等于 | a=4; a/=2; | a=2; |
| %= | 模等于 | a=3; a%2; | a=1; |
作用：用于表达式的比较，并返回一个真值或假值
- 请详细看表格即可
| 运算符 | 术语 | 示例 | 结果 |
| — | — | — | — |
| == | 相等于 | 4 == 3 | 0 |
| != | 不等于 | 4 != 3 | 1 |
| < | 小于 | 4 < 3 | 0 |
| > | 大于 | 4 > 3 | 1 |
| <= | 小于等于 | 4 <= 3 | 0 |
| >= | 大于等于 | 4 >= 1 | 1 |
注意：C和C++ 语言的比较运算中， “真”用数字“1”来表示， “假”用数字“0”来表示。
作用：用于根据表达式的值返回真值或假值
- 请详细看表格即可
| 运算符 | 术语 | 示例 | 结果 |
| — | — | — | — |
| ! | 非 | !a | 如果a为假，则!a为真； 如果a为真，则!a为假。 |
| && | 与 | a && b | 如果a和b都为真，则结果为真，否则为假。 |
| || | 或 | a || b | 如果a和b有一个为真，则结果为真，二者都为假时，结果为假。 |
!非为三者中运算符最高的
========================================================================
3.1.1、if语句
- if语句较为简单，常常搭配else使用，且可以嵌套使用
3.1.2、三目运算符
作用： 通过三目运算符实现简单的判断
语法：表达式1 ? 表达式2 ：表达式3
如果表达式1的值为真，执行表达式2，并返回表达式2的结果；
如果表达式1的值为假，执行表达式3，并返回表达式3的结果。
- 此处常出程序阅读题！！！！
3.1.3、switch语句
作用：执行多条件分支语句
语法：
switch(表达式)
{
case 结果1：执行语句;break;
case 结果2：执行语句;break;
…
default:执行语句;break;
}
-
switch语句中表达式类型只能是整型或者字符型
-
case里如果没有break，那么程序会一直向下执行
3.2.1、while
作用：满足循环条件，执行循环语句
语法：while(循环条件){ 循环语句 }
**解释：**只要循环条件的结果为真，就执行循环语句
3.2.2、do…while
作用： 满足循环条件，执行循环语句
语法： do{ 循环语句 } while(循环条件);
注意：与while的区别在于do…while会先执行一次循环语句，再判断循环条件（这里常考两者区别，记住无论怎样，do…while都会必然执行一次循环语句）
3.2.3、for
- for循环中的表达式，要用分号进行分隔
int main() {
for (int i = 0; i < 10; i++)
{
cout << i << endl;
}
system(“pause”);
return 0;
}
3.3.1、break
作用: 用于跳出选择结构或者循环结构
3.3.2、continue
作用：在循环语句中，跳过本次循环中余下尚未执行的语句，继续执行下一次循环
注意：continue并没有使整个循环终止，而break会跳出循环
======================================================================
数组：所谓数组，就是一个集合，存放相同类型的数据元素
-
数组中的每个数据元素都是相同的数据类型
-
数组是由连续的内存位置组成的
一维数组定义的三种方式：
-
数据类型 数组名[ 数组长度 ];(常用，了解其余两种即可) -
数据类型 数组名[ 数组长度 ] = { 值1，值2 ...}; -
数据类型 数组名[ ] = { 值1，值2 ...};
int score[10];
int score2[10] = { 100, 90,80,70,60,50,40,30,20,10 };
int score3[] = { 100,90,80,70,60,50,40,30,20,10 };
-
数组中下标是从0开始索引
-
在对全部数组元素赋初值时，可以不指定数组长度
-
直接打印数组名，可以查看数组所占内存的首地址
-
对数组名进行sizeof，可以获取整个数组占内存空间的大小
-
以上三种方式并不要求都会，但是需要都见过，防止在程序改错中乱改
4.1.1、一维数组初始化
- 在定义数组时分别对数组元素赋予初值。例如
int a[10]={0，1，2，3，4，5，6，7，8，9};
- 可以只给一部分元素赋值。例如
int a[10]={0,1,2,3,4};
- 如果想使一个数组中全部元素值为1，可以写成
int a[10]={1，1，1，1，1，1，1，1，1，1};
int a[10］={1*10}; // 错误写法,不能给数组整体赋初值
- 在对全部数组元素赋初值时，可以不指定数组长度
int a[5]={1，2，3，4，5};
// 可以写成
int a[]={1，2，3，4，5};
二维数组定义的四种方式：
-
数据类型 数组名[ 行数 ][ 列数 ]; -
数据类型 数组名[ 行数 ][ 列数 ] = { {数据1，数据2 } ，{数据3，数据4 } }; -
数据类型 数组名[ 行数 ][ 列数 ] = { 数据1，数据2，数据3，数据4}; -
数据类型 数组名[ ][ 列数 ] = { 数据1，数据2，数据3，数据4};
int arr[2][3];
int arr2[2][3] =
{
{1,2,3},
{4,5,6}
};
int arr3[2][3] = { 1,2,3,4,5,6 };
int arr4[][3] = { 1,2,3,4,5,6 };
-
以上4种定义方式，利用第二种更加直观，提高代码的可读性
-
如果对全部元素赋初值，定义数组时对第一维的长度可以不指定，但是第二维的长度不能省略
- 用来存放字符数据的数组是字符数组，字符数组中的一个元素存放一个字符
定义：
char c[10] = {′I′,′ ′,′a′,′m′,′ ′,′h′,′a′,′p′,′p′,′y′};
赋值：
只能对字符数组的元素赋值，而不能用赋值语句对整个数组赋值
char c[5];
c={′C′,′h′,′i′,′n′,′a′}; //错误，不能对整个数组一次赋值
C[0]=′C′; c[1]=′h′; c[2]=′i′; c[3]=′n′; c[4]=′a′; //对数组元素赋值，正确
int a[5],b[5]={1,2,3,4,5};
a=b; //错误，不能对整个数组整体赋值
a[0]=b[0]; //正确，引用数组元素
-
字符串连接函数
strcat -
字符串复制函数
strcpy -
字符串比较函数
strcmp -
字符串长度函数
strlen
======================================================================
作用：将一段经常使用的代码封装起来，减少重复代码
函数的定义一般主要有5个步骤：
1、返回值类型
2、函数名
3、参数表列
4、函数体语句
5、return 表达式
语法：
返回值类型 函数名 （参数列表）
{
函数体语句
return表达式
}
-
返回值类型 ：一个函数可以返回一个值。在函数定义中
-
函数名：给函数起个名称
-
参数列表：使用该函数时，传入的数据
-
函数体语句：花括号内的代码，函数内需要执行的语句
-
return表达式： 和返回值类型挂钩，函数执行完后，返回相应的数据
示例：定义一个加法函数，实现两个数相加
//函数定义
int add(int num1, int num2)
{
int sum = num1 + num2;
return sum;
}
功能：使用定义好的函数
语法：函数名（参数）
int result = add(10,20);
-
函数定义里小括号内称为形参，函数调用时传入的参数称为实参
-
例如此处的
num1,num2为形参，10,20为实参 -
函数不能嵌套定义但是可以嵌套调用（常考）
- 函数的声明可以多次，但是函数的定义只能有一次
//声明可以多次，定义只能一次
//声明
int max(int a, int b);
int max(int a, int b);
//定义
int max(int a, int b)
{
return a > b ? a : b;
}
int main() {
int a = 100;
int b = 200;
cout << max(a, b) << endl;
system(“pause”);
return 0;
}
-
所谓值传递，即单向传递，就是函数调用时实参将数值传入给形参，而不能由形参传回来给实参。
-
值传递时，如果形参发生改变，并不会影响实参（值传递时，形参是修饰不了实参的），请务必理解并记住，此处因篇幅就不进行讲解了！
在C++中，函数的形参列表中的形参是可以有默认值的。
语法：返回值类型 函数名 （参数= 默认值）{}
int func(int a, int b = 10, int c = 10) {
return a + b + c;
}
//1. 如果某个位置参数有默认值，那么从这个位置往后，从左向右，必须都要有默认值
//2. 如果函数声明有默认值，函数实现的时候就不能有默认参数
int func2(int a = 10, int b = 10);
int func2(int a, int b) {
return a + b;
}
int main() {
cout << "ret = " << func(20, 20) << endl;
cout << "ret = " << func(100) << endl;
system(“pause”);
return 0;
}
-
如果某个位置参数有默认值，那么从这个位置往后，从左向右，必须都要有默认值
-
如果函数声明有默认值，函数实现的时候就不能有默认参数
C++中函数的形参列表里可以有占位参数，用来做占位，调用函数时必须填补该位置
语法： 返回值类型 函数名 (数据类型){}
//函数占位参数 ，占位参数也可以有默认参数
void func(int a, int) {
cout << “this is func” << endl;
}
int main() {
func(10,10); //占位参数必须填补
system(“pause”);
return 0;
}
作用：函数名可以相同，提高复用性
函数重载满足条件：
-
函数名称相同
-
函数参数类型不同 或者 个数不同 或者 顺序不同
注意: 函数的返回值不可以作为函数重载的条件
//函数重载需要函数都在同一个作用域下
void func()
{
cout << “func 的调用！” << endl;
}
void func(int a)
{
cout << “func (int a) 的调用！” << endl;
}
void func(double a)
{
cout << “func (double a)的调用！” << endl;
}
void func(int a ,double b)
{
cout << “func (int a ,double b) 的调用！” << endl;
}
void func(double a ,int b)
{
cout << “func (double a ,int b)的调用！” << endl;
}
//函数返回值不可以作为函数重载条件
//int func(double a, int b)
//{
// cout << “func (double a ,int b)的调用！” << endl;
//}
int main() {
func();
func(10);
func(3.14);
func(10,3.14);
func(3.14 , 10);
system(“pause”);
return 0;
}
C++中有以下五个运算符不能重载
| 成员访问运算符 | 成员指针访问运算符 | 域运算符 | 长度运算符 | 条件运算符 |
| — | — | — | — | — |
| . | .* | ：： | sizeof | ？： |
重载运算符规则：
-
重载不能改变运算符运算对象（即操作数）的个数
-
重载不能改变运算符的优先级别
-
重载不能改变运算符的结合性
-
运算符重载函数可以是类的成员函数，也可以是类的友元函数，还可以是既非类的成员函数也不是友元函数的普通函数
什么时候应该用成员函数方式，什么时候应该用友元函数方式？二者有何区别呢？（）
-
一般将单目运算符重载为成员函数，将双目运算符（二元运算符）重载为友元函数
-
重载为类的成员函数 -
operator函数有一个参数 -
重载为类的友元函数 -
operator函数有两个参数 -
只能将重载
“>>”（流插入运算符）和“<<”（流提取运算符）的函数作为友元函数或者普通函数重载，而不能将它们定义为成员函数，因为参数为两个 -
类型转换运算符只能作为成员函数重载
单目运算符：只有一个操作数，如 !，-(负号)，&，*，++，–
双目运算符：*，/，%，+，-，==，!=，<,>,<=,>=,&&，||
- 指定内置函数的方法很简单，只需在函数首行的左端加一个关键字inline即可。
inline int max(int a,int b);
-
使用内置函数可以节省运行时间
-
只有那些规模较小而又被频繁调用的简单函数，才适合于声明为inline函数。
语法：
template
函数声明或定义
解释：
template — 声明创建模板
typename — 表面其后面的符号是一种数据类型，可以用class代替
T — 通用的数据类型，名称可以替换，通常为大写字母
只适用于函数体相同、函数的参数个数相同而类型不同的情况，如果参数的个数不同，则不能用函数模板。
======================================================================
指针的作用： 可以通过指针间接访问内存
指针变量定义语法： 数据类型 * 变量名；
- 请看下方代码示例，理解指针变量的定义与使用，期末一般不会出太难指针的题，但是基本用法一定要会！！
int main() {
//1、指针的定义
int a = 10; //定义整型变量a
//指针定义语法： 数据类型 * 变量名 ;
int * p;
//指针变量赋值
p = &a; //指针指向变量a的地址
cout << &a << endl; //打印数据a的地址
cout << p << endl; //打印指针变量p
//0073F8BC
//0073F8BC
//2、指针的使用
//通过*操作指针变量指向的内存
cout << "*p = " << *p << endl;
// *p = 10
system(“pause”);
return 0;
}
指针变量和普通变量的区别
-
普通变量存放的是数据,指针变量存放的是地址
-
指针变量可以通过" * "操作符，操作指针变量指向的内存空间，这个过程称为解引用
总结1： 我们可以通过 & 符号 获取变量的地址
总结2：利用指针可以记录地址
总结3：对指针变量解引用，可以操作指针指向的内存
总结4：所有指针类型在32位操作系统下是4个字节（了解）
const修饰指针有三种情况
-
const修饰指针 — 常量指针
-
const修饰常量 — 指针常量
-
const既修饰指针，又修饰常量
int main() {
int a = 10;
int b = 10;
//const修饰的是指针，指针指向可以改，指针指向的值不可以更改
const int * p1 = &a;
p1 = &b; //正确
//*p1 = 100; 报错
//const修饰的是常量，指针指向不可以改，指针指向的值可以更改
int * const p2 = &a;
//p2 = &b; //错误
*p2 = 100; //正确
//const既修饰指针又修饰常量
const int * const p3 = &a;
//p3 = &b; //错误
//*p3 = 100; //错误
system(“pause”);
return 0;
}
技巧：看const右侧紧跟着的是指针还是常量, 是指针就是常量指针，是常量就是指针常量
作用：利用指针访问数组中元素
-
C++规定，数组名就是数组的起始地址
-
数组的指针就是数组的起始地址
-
数组名可以作函数的实参和形参，传递的是数组的地址
int main() {
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
int * p = arr; //指向数组的指针
cout << "第一个元素： " << arr[0] << endl; //1
cout << "指针访问第一个元素： " << *p << endl; //1
for (int i = 0; i < 10; i++)
{
//利用指针遍历数组
cout << *p << endl;
p++;
}
system(“pause”);
return 0;
}
作用：利用指针作函数参数，可以修改实参的值（地址传递）
//值传递
void swap1(int a ,int b)
{
int temp = a;
a = b;
b = temp;
}
//地址传递
void swap2(int * p1, int *p2)
{
int temp = *p1;
*p1 = *p2;
*p2 = temp;
}
int main() {
int a = 10;
int b = 20;
swap1(a, b); // 值传递不会改变实参
swap2(&a, &b); //地址传递会改变实参
cout << "a = " << a << endl;
cout << "b = " << b << endl;
system(“pause”);
return 0;
}
int a[10];
int *p = &a[0]; // 等价于 int *p = a;
*p = 1; // 等价于 a[0] = 1;
*(p+1) = 2; // 等价于 a[1] = 2;
// 所以 *(p+1) = a[1]; *(p+2) = a[2];
- C++规定， p+1 指向数组的 下一个元素
void main()
{
int array[10];
// 用数组名作形参，因为接收的是地址，所以可以不指定具体的元素个数
f(array,10);
}
// 形参数组
f(int arr[],int n)
{
…
}
void main()
{
int a[10];
// 实参数组
f(a,10);
}
// 形参指针
f(int *x,int n)
{
…
}
总结：如果不想修改实参，就用值传递，如果想修改实参，就用地址传递
-
返回指针值的函数简称指针函数。
-
定义指针函数的一般形式为：
// 类型名 * 函数名（参数列表）
int * a(int x,int y);
======================================================================
作用： 给变量起别名
语法： 数据类型 &别名 = 原名
int main() {
int a = 10;
int &b = a;
cout << "a = " << a << endl;
cout << "b = " << b << endl;
// 10
// 10
b = 100;
cout << "a = " << a << endl;
cout << "b = " << b << endl;
// 100
// 100
system(“pause”);
return 0;
}
- 引用必须初始化
int &c; // 错误，引用必须初始化
- 在声明一个引用后，不能再使之作为另一变量的引用
作用：函数传参时，可以利用引用的技术让形参修饰实参
优点：可以简化指针修改实参
- 通过引用参数产生的效果同按地址传递是一样的。引用的语法更清楚简单
//1. 值传递
void mySwap01(int a, int b) {
int temp = a;
a = b;
b = temp;
}
//2. 地址传递
void mySwap02(int* a, int* b) {
int temp = *a;
*a = *b;
*b = temp;
}
//参数：把地址传进去，用指针接收
//3. 引用传递
void mySwap03(int& a, int& b) {
int temp = a;
a = b;
b = temp;
}
//参数：别名，下面的a是上面的a的别名，用别名操作修改可原名操作修改是一样的
int main() {
int a = 10;
int b = 20;
// 值传递，形参不会修饰实参
mySwap01(a, b);
cout << “a:” << a << " b:" << b << endl;
// a:10 b:20
// 地址传递，形参会修饰实参
mySwap02(&a, &b);
cout << “a:” << a << " b:" << b << endl;
// a:20 b:10
// 引用传递，形参会修饰实参
mySwap03(a, b);
cout << “a:” << a << " b:" << b << endl;
// a:20 b:10
system(“pause”);
return 0;
}
作用：引用是可以作为函数的返回值存在的
//数据类型后加&，相当于用引用的方式返回
int& test02() {
// 必须使用静态变量,需加 static 关键字
static int a = 20;
return a;
}
int main(){
int& ref2 = test02();
system(“pause”);
return 0;
}
========================================================================
在C++中 struct和class唯一的区别就在于 默认的访问权限不同
区别：
-
struct 默认权限为公共
-
class 默认权限为私有
-
构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。
-
析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作。
构造函数语法：类名(){}（构造和析构很容易出选择题，特点要记住）
-
构造函数，没有返回值也不写void
-
构造函数的名字必须与类名相同
-
构造函数可以有参数，因此可以发生重载
-
程序在调用对象时候会自动调用构造函数，无须手动调用,而且只会调用一次（构造函数不需用户调用，也不能被用户调用）
析构函数语法： ~类名(){}
-
析构函数，没有返回值也不写void
-
函数名称与类名相同,在名称前加上符号
~ -
析构函数不可以有参数，因此不可以发生重载
-
程序在对象销毁前会自动调用析构，无须手动调用,而且只会调用一次
class Person
{
public:
//构造函数
Person()
{
cout << “Person的构造函数调用” << endl;
}
//析构函数
~Person()
{
cout << “Person的析构函数调用” << endl;
}
};
void test01()
{
Person p; //在栈上的数据，test01()执行完毕后，释放这个对象
}
int main() {
test01();
system(“pause”);
return 0;
}
构造函数按参数分为： 有参构造和无参构造
调用方式：括号法
class Person {
public:
//无参（默认）构造函数
Person() {
cout << “无参构造函数!” << endl;
}
//有参构造函数
Person(int a) {
age = a;
cout << “有参构造函数!” << endl;
}
//析构函数
~Person() {
cout << “析构函数!” << endl;
}
public:
int age;
};
//2、构造函数的调用
//调用无参构造函数
void test01() {
Person p; //调用无参构造函数
}
//调用有参的构造函数
void test02() {
// 括号法，常用
Person p1(10);
}
- 尽管在一个类中可以包含多个构造函数，但是对于每一个对象来说，建立对象时只执行其中一个构造函数，并非每个构造函数都被执行
- C++提供了初始化列表语法，用来初始化属性
语法：构造函数()：属性1(值1),属性2（值2）... {}
class Person {
public:
传统方式初始化
//Person(int a, int b, int c) {
// m_A = a;
// m_B = b;
// m_C = c;
//}
//初始化列表方式初始化
Person(int a, int b, int c) :m_A(a), m_B(b), m_C© {}
void PrintPerson() {
cout << “mA:” << m_A << endl;
cout << “mB:” << m_B << endl;
cout << “mC:” << m_C << endl;
}
private:
int m_A;
int m_B;
int m_C;
};
int main() {
Person p(1, 2, 3);
p.PrintPerson();
system(“pause”);
return 0;
}
C++类中的成员可以是另一个类的对象，我们称该成员为 对象成员
例如：
class A {}
class B
{
A a；
}
-
B类中有对象A作为成员，A为对象成员
-
那么当创建B对象时，A与B的构造和析构的顺序是谁先谁后？
-
先调用对象成员的构造，再调用本类构造(如上例中，先调用A的构造函数)
-
析构顺序与构造相反
静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员
静态成员分为：
-
静态成员变量
-
所有对象共享同一份数据
-
在编译阶段分配内存
-
类内声明，类外初始化
-
静态成员函数
-
所有对象共享同一个函数
-
静态成员函数只能访问静态成员变量
**示例1 **：静态成员变量
class Person
{
public:
static int m_A; //静态成员变量
//静态成员变量特点：
//1 在编译阶段分配内存
//2 类内声明，类外初始化
//3 所有对象共享同一份数据
private:
static int m_B; //静态成员变量也是有访问权限的
};
int Person::m_A = 10;
int Person::m_B = 10;
void test01()
{
//静态成员变量两种访问方式
//1、通过对象
Person p1;
p1.m_A = 100;
cout << "p1.m_A = " << p1.m_A << endl;
Person p2;
p2.m_A = 200;
cout << "p1.m_A = " << p1.m_A << endl; //共享同一份数据
cout << "p2.m_A = " << p2.m_A << endl;
//2、通过类名
cout << "m_A = " << Person::m_A << endl;
//cout << "m_B = " << Person::m_B << endl; //私有权限访问不到
}
int main() {
test01();
system(“pause”);
return 0;
}
示例2：静态成员函数
class Person
{
public:
//静态成员函数特点：
//1 程序共享一个函数
//2 静态成员函数只能访问静态成员变量
static void func()
{
cout << “func调用” << endl;
m_A = 100;
//m_B = 100; //错误，不可以访问非静态成员变量
}
static int m_A; //静态成员变量
int m_B; //
private:
//静态成员函数也是有访问权限的
static void func2()
{
cout << “func2调用” << endl;
}
};
int Person::m_A = 10;
void test01()
{
//静态成员变量两种访问方式
//1、通过对象
Person p1;
p1.func();
//2、通过类名
Person::func();
//Person::func2(); //私有权限访问不到
}
int main() {
test01();
system(“pause”);
return 0;
}
标签：知识点,函数,10,int,C++,运算符,期末,指针,cout From： https://blog.csdn.net/2401_86436674/article/details/142052975