C++基础知识--考前浏览

注意：C++风格字符串，需要加入头文件==#include<string>==

字符串常量为双引号

常考：字符串 "abc" 在内存中占几个字节？

答：占4个字节，而不是3个字节，编译系统会在字符串最后自动加一个′＼0′作为字符串结束标志。但′＼0′并不是字符串的一部分，它只作为字符串的结束标志

常考: 字符串常量″abc＼n″包含几个字符?

答：不是5个而是4个字符，其中“＼n”是一个转义字符,但它在内存中占5个字节

7、布尔类型bool

作用：布尔数据类型代表真或假的值

bool类型只有两个值：

true — 真（本质是1）
false — 假（本质是0）
bool类型占1个字节大小

8、数据的输入输出

关键字：cin、cout

语法： cin >> 变量1>>变量2>>....>>变量n、cout<<表达式1<<表达式2<<...<<表达式n

cout<<a,b,c; //错误，不能一次插入多项cout<<a+b+c; //正确，这是一个表达式，作为一项cin>>a>>b>>c>>d;

9、变量命名规则

C++规定标识符只能由字母、数字和下划线3种字符组成，且第一个字符必须为字母或下划线
不能是关键字
区分大小写

10、局部变量

在一个函数内部定义的变量是局部变量，它只在本函数范围内有效，也就是说只有在本函数内才能使用它们，在此函数以外是不能使用这些变量的
形参也是局部变量

11、全局变量

在函数之外定义的变量是外部变量，称为全局变量

二、运算符总结

1.算术运算符

注意：

两个整数相除结果依然是整数（这里不进行四舍五入，直接舍去小数点后面数字）

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;
}

2.赋值运算符

作用：用于将表达式的值赋给变量

请详细看表格即可

3.比较运算符

作用：用于表达式的比较，并返回一个真值或假值

4.逻辑运算符

作用：用于根据表达式的值返回真值或假值

!非为三者中运算符最高的

三、流程结构总结

1、选择结构

1.1、if语句

if语句较为简单，常常搭配else使用，且可以嵌套使用

1.2、三目运算符

作用：通过三目运算符实现简单的判断

语法：表达式1 ? 表达式2 ：表达式3

如果表达式1的值为真，执行表达式2，并返回表达式2的结果；

如果表达式1的值为假，执行表达式3，并返回表达式3的结果。

此处常出程序阅读题！！！！

1.3、switch语句

作用：执行多条件分支语句

语法：

switch(表达式)

{ case 结果1：执行语句;break; case 结果2：执行语句;break;

... default:执行语句;break;

}

switch语句中表达式类型只能是整型或者字符型

case里如果没有break，那么程序会一直向下执行

case穿透现象: 在switch语句中，如果case控制的语句体后面不写break，将出现穿透现象，在不判断下一个case值的情况下，向下运行，直到遇到break，或者整体switch语句结束。

2、循环结构

2.1、while

作用：满足循环条件，执行循环语句

语法：while(循环条件){ 循环语句 }

解释：只要循环条件的结果为真，就执行循环语句

2.2、do…while

作用：满足循环条件，执行循环语句

语法： do{ 循环语句 } while(循环条件);

注意：与while的区别在于do…while会先执行一次循环语句，再判断循环条件（这里常考两者区

别，记住无论怎样，do…while都会必然执行一次循环语句）

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.2、continue

作用：在循环语句中，跳过本次循环中余下尚未执行的语句，继续执行下一次循环

注意：continue并没有使整个循环终止，而break会跳出循环

四、数组

数组：所谓数组，就是一个集合，存放相同类型的数据元素

数组中的每个数据元素都是相同的数据类型
数组是由连续的内存位置组成的

1、一维数组

一维数组定义的三种方式：

数据类型数组名[ 数组长度 ];(常用，了解其余两种即可)
数据类型数组名[ 数组长度 ] = { 值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，可以获取整个数组占内存空间的大小

以上三种方式并不要求都会，但是需要都见过，防止在程序改错中乱改

一维数组初始化

在定义数组时分别对数组元素赋予初值。例如

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};

2、二维数组

二维数组定义的四种方式：

数据类型数组名[ 行数 ][ 列数 ];

数据类型数组名[ 行数 ][ 列数 ] = { {数据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种定义方式，利用第二种更加直观，提高代码的可读性如果对全部元素赋初值，定义数组时对第一维的长度可以不指定，但是第二维的长度不能省略

3、字符数组

用来存放字符数据的数组是字符数组，字符数组中的一个元素存放一个字符

定义：

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]; //正确，引用数组元素

4、字符串函数

字符串连接函数 strcat

字符串复制函数 strcpy

字符串比较函数 strcmp

字符串长度函数 strlen

五、函数总结

作用：将一段经常使用的代码封装起来，减少重复代码

1、函数定义

函数的定义一般主要有5个步骤：

返回值类型

函数名

参数表列

函数体语句

return 表达式

返回值类型函数名（参数列表）
{

函数体语句 return表达式

}

返回值类型：一个函数可以返回一个值。在函数定义中

函数名：给函数起个名称

参数列表：使用该函数时，传入的数据

函数体语句：花括号内的代码，函数内需要执行的语句

return表达式：和返回值类型挂钩，函数执行完后，返回相应的数据

示例：定义一个加法函数，实现两个数相加

//函数定义int add(int num1, int num2){ int sum = num1 + num2; return sum;
}

2、函数调用

功能：使用定义好的函数

语法：函数名（参数）

int result = add(10,20);

函数定义里小括号内称为形参，函数调用时传入的参数称为实参

例如此处的num1,num2 为形参，10,20为实参

函数不能嵌套定义但是可以嵌套调用（常考）

3、函数声明

函数的声明可以多次，但是函数的定义只能有一次

//声明可以多次，定义只能一次//声明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;
}

4、值传递

所谓值传递，即单向传递，就是函数调用时实参将数值传入给形参，而不能由形参传回来给实参

值传递时，如果形参发生改变，并不会影响实参（值传递时，形参是修饰不了实参的），请务必

解并记住，此处因篇幅就不进行讲解了！

5、函数默认参数

在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;
}

如果某个位置参数有默认值，那么从这个位置往后，从左向右，必须都要有默认值

如果函数声明有默认值，函数实现的时候就不能有默认参数

6、函数占位参数

C++中函数的形参列表里可以有占位参数，用来做占位，调用函数时必须填补该位置

语法：返回值类型函数名 (数据类型){}

//函数占位参数，占位参数也可以有默认参数void func(int a, int) {
cout << "this is func" << endl;
}int main() { func(10,10); //占位参数必须填补

system("pause"); return 0;
}

六、指针

指针的作用：可以通过指针间接访问内存

1、指针变量

指针变量定义语法：数据类型 * 变量名；

请看下方代码示例，理解指针变量的定义与使用，期末一般不会出太难指针的题，但是基本用法一定要会！！

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个字节（了解）

2、const修饰指针

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右侧紧跟着的是指针还是常量, 是指针就是常量指针，是常量就是指针常量

3、指针和数组

作用：利用指针访问数组中元素

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;
}

4、指针和函数

作用：利用指针作函数参数，可以修改实参的值（地址传递）

//值传递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)
{
   ...
}

总结：如果不想修改实参，就用值传递，如果想修改实参，就用地址传递

4、返回指针值的函数

返回指针值的函数简称指针函数。

定义指针函数的一般形式为：

// 类型名 * 函数名（参数列表）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;
}

1、引用注意事项

引用必须初始化

int &c; // 错误，引用必须初始化

在声明一个引用后，不能再使之作为另一变量的引用

2、引用做函数参数

作用：函数传参时，可以利用引用的技术让形参修饰实参

优点：可以简化指针修改实参

通过引用参数产生的效果同按地址传递是一样的。引用的语法更清楚简单

//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;
}

3、引用做函数返回值

作用：引用是可以作为函数的返回值存在的

//数据类型后加&，相当于用引用的方式返回 int& test02() { // 必须使用静态变量,需加 static 关键字
static int a = 20; return a;
}int main(){ int& ref2 = test02(); system("pause"); return 0;
}