C++基础语法——蓝桥杯备战D1-2

一杯冰镇过的杨梅汁呐

已于 2024-01-22 23:35:24 修改

阅读量1.1k

点赞数 21

文章标签： c++ 开发语言

于 2024-01-21 23:12:46 首次发布

本文链接：https://blog.csdn.net/2301_79706722/article/details/135733354

版权

C++是什么

C++是一种通用的编程语言，是对C语言的扩展和增强。它于1980年代由丹尼斯·里奇（Dennis Ritchie）开发，并在之后由Bjarne Stroustrup进一步发展完善。C++具有高级的抽象能力和面向对象的特性，同时也保留了C语言的低级编程特性。

C++被广泛应用于软件开发、系统编程、嵌入式系统、游戏开发等领域。它支持面向对象编程（OOP）的概念，如类、继承、多态等，也支持泛型编程（Generic Programming），提供了模板（Template）机制。C++还拥有丰富的标准库，包括输入输出、容器、算法、文件操作等功能，以及对多线程和并发编程的支持。

C++语言具有高效性、灵活性和可移植性等特点，可以通过编译器将C++代码转换为可执行的机器码，从而在不同的操作系统和硬件平台上运行。它是一种功能强大且广泛使用的编程语言，在工业界和学术界都有重要的地位。

C++的基础语法包括哪些内容

与python及所有编程语言相似，C++包括注释、标识符、变量和数据类型、常量、运算符、数组、控制流语句、函数等，当然，C++还有更多高级特性和语法，如指针、引用、面向对象的继承、多态等，这些将在后面的学习中接触到。

1.变量和数据类型

变量是程序可操作的存储区的名称。

C++ 中每个变量都有指定的类型，类型决定了变量存储的大小和布局，该范围内的值都可以存储在内存中。

变量的名称可以由字母、数字和下划线字符组成，它必须以字母或下划线开头。

变量的分类


类型	描述
bool	布尔类型，存储值 true 或 false，占用 1 个字节
char	字符类型，用于存储 ASCII 字符，通常占用 1 个字节
int	整数类型，通常用于存储普通整数，通常占用 4 个字节
float	单精度浮点值，用于存储单精度浮点数。单精度是这样的格式，1 位符号，8 位指数，23 位小数，通常占用4个字节
double	双精度浮点值，用于存储双精度浮点数。双精度是 1 位符号，11 位指数，52 位小数，通常占用 8 个字节
void	表示类型的缺失
wchar_t	宽字符类型，用于存储更大范围的字符，通常占用 2 个或 4 个字节

常用的数据类型

整数类型	描述
`int`	用于表示整数，通常占用4个字节
`short`	用于表示短整数，通常占用2个字节
`long`	用于表示长整数，通常占用4个字节
`long long`	用于表示更长的整数，通常占用8个字节

浮点类型	描述
`float`	用于表示单精度浮点数，通常占用4个字节
`double`	用于表示双精度浮点数，通常占用8个字节
`long double`	用于表示更高精度的浮点数，占用字节数可以根据实现而变化

字符类型	描述
`char`	用于表示字符，通常占用1个字节
`wchar_t`	用于表示宽字符，通常占用2或4个字节
`char16_t`	用于表示16位Unicode字符，占用2个字节
`char32_t`	用于表示32位Unicode字符，占用4个字节

语法：数据类型变量名 = 初始值;

#include<iostream>
using namespace std;

int main() {

	//变量的定义
	//语法：数据类型  变量名 = 初始值

	int a = 10;  //注意：C++在创建变量时，必须给变量一个初始值，否则会报错
	cout << "a = " << a << endl;
	
	system("pause");

	return 0;
}

2.运算符

运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。

包括以下内容：

算术运算符

作用：用于处理四则运算

运算符	术语	示例	结果
++	前置递增	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;

（与python一致的不再赘述，只保留不同的部分）

（只有整型变量可以进行取模运算；前置递增先对变量进行++，再计算表达式，后置递增相反 ）

example:

//递增
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;

	//后置递增先计算表达式，后对变量进行++
	int a3 = 10;
	int b3 = a3++ * 10;
	cout << b3 << endl;

	system("pause");

	return 0;
}

关系运算符

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

运算符	术语	示例	结果
==	相等于	4 == 3	0
!=	不等于	4 != 3	1
<	小于	4 < 3	0
>	大于	4 > 3	1
<=	小于等于	4 <= 3	0
>=	大于等于	4 >= 1	1

（注意：C和C++ 语言的比较运算中， ==“真”用数字“1”来表示， “假”用数字“0”来表示。）

example:

int main() {

	int a = 10;
	int b = 20;

	cout << (a == b) << endl; // 0 

	cout << (a != b) << endl; // 1

	cout << (a > b) << endl; // 0

	cout << (a < b) << endl; // 1

	cout << (a >= b) << endl; // 0

	cout << (a <= b) << endl; // 1
	
	system("pause");

	return 0;
}

逻辑运算符

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

运算符	术语	示例	结果
!（not）	非	!a	如果a为假，则!a为真；如果a为真，则!a为假。
&&（and）	与	a && b	如果a和b都为真，则结果为真，否则为假。
\|\|（or）	或	a \|\| b	如果a和b有一个为真，则结果为真，二者都为假时，结果为假。

（括号内为python的同等运算符）

example:

//逻辑运算符  --- 非
int main() {

	int a = 10;

	cout << !a << endl; // 0

	cout << !!a << endl; // 1

	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;

运算符的优先级

运算符的优先级确定表达式中项的组合。这会影响到一个表达式如何计算。某些运算符比其他运算符有更高的优先级

类别	运算符	结合性
后缀	() [] -> . ++ - -	从左到右
一元	+ - ! ~ ++ - - (type)* & sizeof	从右到左
乘除	* / %	从左到右
加减	+ -	从左到右
移位	<< >>	从左到右
关系	< <= > >=	从左到右
相等	== !=	从左到右
位与AND	&	从左到右
位异或XOR	^	从左到右
位或OR	\|	从左到右
逻辑与AND	&&	从左到右
逻辑或OR	\|\|	从左到右
条件	?:	从右到左
赋值	= += -= *= /= %=>>= <<= &= ^= \|=	从右到左
逗号	,	从左到右

example：

#include <iostream>
using namespace std;
 
int main()
{
   int a = 20;
   int b = 10;
   int c = 15;
   int d = 5;
   int e;
 
   e = (a + b) * c / d;      // ( 30 * 15 ) / 5
   cout << "(a + b) * c / d 的值是 " << e << endl ;
 
   e = ((a + b) * c) / d;    // (30 * 15 ) / 5
   cout << "((a + b) * c) / d 的值是 " << e << endl ;
 
   e = (a + b) * (c / d);   // (30) * (15/5)
   cout << "(a + b) * (c / d) 的值是 " << e << endl ;
 
   e = a + (b * c) / d;     //  20 + (150/5)
   cout << "a + (b * c) / d 的值是 " << e << endl ;
  
   return 0;
}

//运行结果如下
(a + b) * c / d 的值是 90
((a + b) * c) / d 的值是 90
(a + b) * (c / d) 的值是 90
a + (b * c) / d 的值是 50

3.数组

C++ 支持数组数据结构，它可以存储一个固定大小的相同类型元素的顺序集合。数组是用来存储一系列数据，但它往往被认为是一系列相同类型的变量。

所有的数组都是由连续的内存位置组成。最低的地址对应第一个元素，最高的地址对应最后一个元素。

一维数组

语法：

数据类型数组名[ 数组长度 ];
数据类型数组名[ 数组长度 ] = { 值1，值2 ...};
数据类型数组名[ ] = { 值1，值2 ...};

大括号 { } 之间的值的数目不能大于在数组声明时在方括号 [ ] 中指定的元素数目。

如果省略掉了数组的大小，数组的大小则为初始化时元素的个数。

example:

int main() {

	//定义方式1
	//数据类型 数组名[元素个数];
	int score[10];

	//利用下标赋值
	score[0] = 100;
	score[1] = 99;
	score[2] = 85;

	//利用下标输出
	cout << score[0] << endl;
	cout << score[1] << endl;
	cout << score[2] << endl;


	//第二种定义方式
	//数据类型 数组名[元素个数] =  {值1，值2 ，值3 ...};
	//如果{}内不足10个数据，剩余数据用0补全
	int score2[10] = { 100, 90,80,70,60,50,40,30,20,10 };
	
	//逐个输出
	//cout << score2[0] << endl;
	//cout << score2[1] << endl;

	//一个一个输出太麻烦，因此可以利用循环进行输出
	for (int i = 0; i < 10; i++)
	{
		cout << score2[i] << endl;
	}

	//定义方式3
	//数据类型 数组名[] =  {值1，值2 ，值3 ...};
	int score3[] = { 100,90,80,70,60,50,40,30,20,10 };

	for (int i = 0; i < 10; i++)
	{
		cout << score3[i] << endl;
	}

	system("pause");

	return 0;
}

(数组名的命名规范与变量名命名规范一致，不要和变量重名)

二维数组

语法：

数据类型数组名[ 行数 ][ 列数 ];
数据类型数组名[ 行数 ][ 列数 ] = { {数据1，数据2 } ，{数据3，数据4 } };
数据类型数组名[ 行数 ][ 列数 ] = { 数据1，数据2，数据3，数据4};
数据类型数组名[ ][ 列数 ] = { 数据1，数据2，数据3，数据4};

example:

int main() {

	//方式1  
	//数组类型 数组名 [行数][列数]
	int arr[2][3];
	arr[0][0] = 1;
	arr[0][1] = 2;
	arr[0][2] = 3;
	arr[1][0] = 4;
	arr[1][1] = 5;
	arr[1][2] = 6;

	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << arr[i][j] << " ";
		}
		cout << endl;
	}

	//方式2 
	//数据类型 数组名[行数][列数] = { {数据1，数据2 } ，{数据3，数据4 } };
	int arr2[2][3] =
	{
		{1,2,3},
		{4,5,6}
	};

	//方式3
	//数据类型 数组名[行数][列数] = { 数据1，数据2 ,数据3，数据4  };
	int arr3[2][3] = { 1,2,3,4,5,6 }; 

	//方式4 
	//数据类型 数组名[][列数] = { 数据1，数据2 ,数据3，数据4  };
	int arr4[][3] = { 1,2,3,4,5,6 };
	
	system("pause");

	return 0;
}

数组名的用途

一维数组名称的用途：

可以统计整个数组在内存中的长度
可以获取数组在内存中的首地址

//数组名用途
   //1、可以获取整个数组占用内存空间大小
   int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };

   cout << "整个数组所占内存空间为： " << sizeof(arr) << endl;
   cout << "每个元素所占内存空间为： " << sizeof(arr[0]) << endl;
   cout << "数组的元素个数为： " << sizeof(arr) / sizeof(arr[0]) << endl;

   //2、可以通过数组名获取到数组首地址
   cout << "数组首地址为： " << (int)arr << endl;
   cout << "数组中第一个元素地址为： " << (int)&arr[0] << endl;
   cout << "数组中第二个元素地址为： " << (int)&arr[1] << endl;

数组名是常量，不可以赋值

直接打印数组名，可以查看数组所占内存的首地址

对数组名进行sizeof，可以获取整个数组占内存空间的大小

二维数组名称的用途：

查看二维数组所占内存空间
获取二维数组首地址

cout << "二维数组大小： " << sizeof(arr) << endl;
   cout << "二维数组一行大小： " << sizeof(arr[0]) << endl;
   cout << "二维数组元素大小： " << sizeof(arr[0][0]) << endl;

   cout << "二维数组行数： " << sizeof(arr) / sizeof(arr[0]) << endl;
   cout << "二维数组列数： " << sizeof(arr[0]) / sizeof(arr[0][0]) << endl;

   //地址
   cout << "二维数组首地址：" << arr << endl;
   cout << "二维数组第一行地址：" << arr[0] << endl;
   cout << "二维数组第二行地址：" << arr[1] << endl;

   cout << "二维数组第一个元素地址：" << &arr[0][0] << endl;
   cout << "二维数组第二个元素地址：" << &arr[0][1] << endl;

二维数组名就是这个数组的首地址

对二维数组名进行sizeof时，可以获取整个二维数组占用的内存空间大小

4.控制流语句

控制流语句：包括条件语句（if、else if、else）、循环语句（for、while、do-while）、跳转语句（break、continue、return）等。

选择结构

if语句

作用：执行满足条件的语句

形式：

单行格式if语句

多行格式if语句

多条件的if语句

语法：

单行格式if语句：if(条件){ 条件满足执行的语句 }（不加分号）

多行格式if语句：if(条件){ 条件满足执行的语句 }else{ 条件不满足执行的语句 };

多条件的if语句：if(条件1){ 条件1满足执行的语句 }else if(条件2){条件2满足执行的语句}... else{ 都不满足执行的语句}

example：

int main() {

	int score = 0;

	cout << "请输入考试分数：" << endl;

	cin >> score;

	if (score > 600)
	{
		cout << "我考上了一本大学" << endl;
		if (score > 700)
		{
			cout << "我考上了北大" << endl;
		}
		else if (score > 650)
		{
			cout << "我考上了清华" << endl;
		}
		else
		{
			cout << "我考上了人大" << endl;
		}
		
	}
	else if (score > 500)
	{
		cout << "我考上了二本大学" << endl;
	}
	else if (score > 400)
	{
		cout << "我考上了三本大学" << endl;
	}
	else
	{
		cout << "我未考上本科" << endl;
	}

	system("pause");

	return 0;
}

三目运算符

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

语法：

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

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

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

example：

int main() {

	int a = 10;
	int b = 20;
	int c = 0;

	c = a > b ? a : b;
	cout << "c = " << c << endl;

	//C++中三目运算符返回的是变量,可以继续赋值

	(a > b ? a : b) = 100;

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;

	system("pause");

	return 0;
}

switch语句

语法：

switch(表达式)

{

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

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

...

default:执行语句;break;

}

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

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

与if语句比，对于多条件判断时，switch的结构清晰，执行效率高，缺点是switch不可以判断区间

example：

int main() {

	//请给电影评分 
	//10 ~ 9   经典   
	// 8 ~ 7   非常好
	// 6 ~ 5   一般
	// 5分以下 烂片

	int score = 0;
	cout << "请给电影打分" << endl;
	cin >> score;

	switch (score)
	{
	case 10:
	case 9:
		cout << "经典" << endl;
		break;
	case 8:
		cout << "非常好" << endl;
		break;
	case 7:
	case 6:
		cout << "一般" << endl;
		break;
	default:
		cout << "烂片" << endl;
		break;
	}

	system("pause");

	return 0;
}

循环结构

while循环语句

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

语法：

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

do...while循环语句

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

语法：

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

与while的区别在于==do...while会先执行一次循环语句==，再判断循环条件

example：

int main() {

	int num = 0;

	do
	{
		cout << num << endl;
		num++;

	} while (num < 10);
	
	
	system("pause");

	return 0;
}

for循环语句

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

语法：

for(起始表达式;条件表达式;末尾循环体) { 循环语句; }

for循环中的表达式，要用分号进行分隔

example：

int main() {

	for (int i = 0; i < 10; i++)
	{
		cout << i << endl;
	}
	
	system("pause");

	return 0;
}

跳转结构

break语句

作用: 用于跳出==选择结构==或者==循环结构==

出现在switch条件语句中，作用是终止case并跳出switch

example:

int main() {
    //1、在switch 语句中使用break
    cout << "请选择您挑战副本的难度：" << endl;
    cout << "1、普通" << endl;
    cout << "2、中等" << endl;
    cout << "3、困难" << endl;

    int num = 0;

    cin >> num;

    switch (num)
    {
    case 1:
        cout << "您选择的是普通难度" << endl;
        break;
    case 2:
        cout << "您选择的是中等难度" << endl;
        break;
    case 3:
        cout << "您选择的是困难难度" << endl;
        break;
    }

    system("pause");

    return 0;
}

continue语句

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

example:

int main() {

	for (int i = 0; i < 100; i++)
	{
		if (i % 2 == 0)
		{
			continue;
		}
		cout << i << endl;
	}
	
	system("pause");

	return 0;
}

goto语句

作用：可以无条件跳转语句

语法：

goto 标记;

如果标记的名称存在，执行到goto语句时，会跳转到标记的位置

example:

int main() {

	cout << "1" << endl;

	goto FLAG;

	cout << "2" << endl;
	cout << "3" << endl;
	cout << "4" << endl;

	FLAG:

	cout << "5" << endl;
	
	system("pause");

	return 0;
}

5.函数

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

一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能。

函数分类

分类：

无参无返
有参无返
无参有返
有参有返

//1、 无参无返
void test01()
{
	//void a = 10; //无类型不可以创建变量,原因无法分配内存
	cout << "this is test01" << endl;
	//test01(); 函数调用
}

//2、 有参无返
void test02(int a)
{
	cout << "this is test02" << endl;
	cout << "a = " << a << endl;
}

//3、无参有返
int test03()
{
	cout << "this is test03 " << endl;
	return 10;
}

//4、有参有返
int test04(int a, int b)
{
	cout << "this is test04 " << endl;
	int sum = a + b;
	return sum;
}

定义函数

步骤：

1、返回值类型 返回值类型：一个函数可以返回一个值。

2、函数名 函数名：给函数起个名称

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

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

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

语法：

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

函数体语句

return表达式

}

example：

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

调用函数

作用：使用定义好的函数

语法：

函数名（参数）

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

//函数定义
int add(int num1, int num2) //定义中的num1,num2称为形式参数，简称形参
{
	int sum = num1 + num2;
	return sum;
}

int main() {

	int a = 10;
	int b = 10;
	//调用add函数
	int sum = add(a, b);//调用时的a，b称为实际参数，简称实参
	cout << "sum = " << sum << endl;

	a = 100;
	b = 100;

	sum = add(a, b);
	cout << "sum = " << sum << endl;

	system("pause");

	return 0;
}

6.结构体

结构体属于用户自定义的数据类型，允许用户存储不同的数据类型

定义结构体

语法：

struct 结构体名 { 结构体成员列表

struct 结构体名变量名

struct 结构体名变量名 = { 成员1值，成员2值...}

}；

定义结构体时的关键字是struct，不可省略

创建结构体变量时，关键字struct可以省略

结构体变量利用操作符 ''.'' 访问成员

example：

//结构体定义
struct student
{
	//成员列表
	string name;  //姓名
	int age;      //年龄
	int score;    //分数
}stu3; //结构体变量创建方式3 


int main() {

	//结构体变量创建方式1
	struct student stu1; //struct 关键字可以省略

	stu1.name = "张三";
	stu1.age = 18;
	stu1.score = 100;
	
	cout << "姓名：" << stu1.name << " 年龄：" << stu1.age  << " 分数：" << stu1.score << endl;

	//结构体变量创建方式2
	struct student stu2 = { "李四",19,60 };

	cout << "姓名：" << stu2.name << " 年龄：" << stu2.age  << " 分数：" << stu2.score << endl;


	stu3.name = "王五";
	stu3.age = 18;
	stu3.score = 80;
	

	cout << "姓名：" << stu3.name << " 年龄：" << stu3.age  << " 分数：" << stu3.score << endl;

	system("pause");

	return 0;
}

结构体数组和指针

作用：将自定义的结构体放入到数组中方便维护，通过指针访问结构体中的成员

语法：

struct 结构体名数组名[元素个数] = { {} , {} , ... {} }

//结构体定义
struct student
{
	//成员列表
	string name;  //姓名
	int age;      //年龄
	int score;    //分数
}

int main() {
	
	//结构体数组
	struct student arr[3]=
	{
		{"张三",18,80 },
		{"李四",19,60 },
		{"王五",20,70 }
	};

	for (int i = 0; i < 3; i++)
	{
		cout << "姓名：" << arr[i].name << " 年龄：" << arr[i].age << " 分数：" << arr[i].score << endl;
	}

	system("pause");

	return 0;
}



//结构体定义
struct student
{
	//成员列表
	string name;  //姓名
	int age;      //年龄
	int score;    //分数
};


int main() {
	
	struct student stu = { "张三",18,100, };
	
	struct student * p = &stu;
	
	p->score = 80; //指针通过 -> 操作符可以访问成员

	cout << "姓名：" << p->name << " 年龄：" << p->age << " 分数：" << p->score << endl;
	
	system("pause");

	return 0;
}