C++基础入门

C++基础入门

1、变量和常量

变量和常量

变量：数据类型 变量名 = 值

常量：

• 宏常量：#define 常量名 值，通常定义在文件上方

  #define Day 7
  1

• const关键字修饰的变量：const 数据类型 常量名 = 值

  const int mouth = 12
  1

变量和常量命名规则

• 不能是关键字
• 只能由字母，数字，下划线组成
• 第一个字符必须为字母或下划线
• 命名中字母区分大小写

2、关键字

关键字

3、数据类型

整数类型：short，int，long，long long，区别在于占用内存空间不同

sizeof关键字：统计数据类型或变量占内存的大小（多少字节）

endl：end of line缩写

long a = 100;
cout << sizeof(a) << endl;   // 4
cout << sizeof(long) << endl;  // 4
1
2
3

浮点型：单精度 float，双精度 double，区别在于有效数字范围不同，默认情况下都显示6位

float f1 = 3.14f;  // 不写f默认为double
double d1 = 3.14;
# 科学计数法
float e1 = 3e2;  // 3 * 10^2
float e2 = 3e-2; // 3 * 10^-2
1
2
3
4
5

字符型：char（一个字节）

• 字符用单引号括起来
• 单引号内只能有一个字符
• 字符型变量存储在内存中的不是字符本身，是字符对应的ASCll编码

char ch = 'a';
1

转义字符：

• \n：换行
• \\：反斜杠
• \t：制表符，整齐输出制表符后面的数据

int main()
{
	cout << "hello \nworld" << endl;
	cout << "\\" << endl;
	cout << "aaaa\tbbbbb" << endl;
	cout << "aa\tbbbbb" << endl;
	cout << "aaaaaa\tbbbbb" << endl;
   //system("pause"): 让程序暂停一下，然后按任意键继续，初学时最多见于程序的末尾处，用于看运行结果，避免程序一闪而过
	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11

字符串型：string

//c 写法
char str[] = "hello world";
// c++ 写法
string str1 = "hello world";
1
2
3
4

布尔类型：True（1），False（0），占一字节内存

bool flag = false;
bool flag1 = true;
1
2

数据的输入输出

cin表示标准输入、cout表示标准输出

使用输入输出时，需要包含头文件iostream

int a = 0;
cin >> a;
cout << "a =" << a << endl;
1
2
3

运算符

算术运算符：

赋值运算符：

比较运算符：

逻辑运算符：

4、流程控制

选择结构

单行 if：

int age = 10;
if (age < 18)
{
	cout << "未成年，请在家长的陪同下观看！" << endl;
}
1
2
3
4
5

多行 if：

int age = 10;
if (age < 18)
{
	cout << "未成年，请在家长的陪同下观看！" << endl;
}
else
{
	cout << "点击播放" << endl;
}
1
2
3
4
5
6
7
8
9

多条件 if：

int age = 0;
cout << "请输入年龄：" << endl;
cin >> age;
if (age < 18 && age > 0)
{
	cout << "未成年" << endl;
}
else if(age >= 18 && age < 35)
{
	cout << "年轻人" << endl;
}
else if (age >= 35 && age < 50)
{
	cout << "中年人" << endl;
}
else if (age >= 50 && age < 120)
{
	cout << "老年人" << endl;
}
else
{
	cout << "不是人" << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

嵌套 if：

int a = 100;
int b = 200;

// 如果条件为真，则进入判断
if (a == 100)
{
    // 如果条件为真，则输出下面的语句
    if (b == 200)
    {
        cout << "a 的值是 100，且 b 的值是 200" << endl;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

三目运算符：

int a = 10;
int b = 20;
int c = 0;
c = a > b ? a : b;
// 20
cout << c << endl;
1
2
3
4
5
6

switch 判断语句：

char level = NULL;
cout << "请输入等级：" << endl;
cin >> level;
switch (level)
{
case 'D':
	cout << "等级D" << endl;
	break;
case 'C':
	cout << "等级C" << endl;
	break;
case 'B':
	cout << "等级B" << endl;
	break;
case 'A':
	cout << "等级A" << endl;
	break;
case 'S':
	cout << "等级S" << endl;
	break;
// default：在case 都不匹配时执行
default:
	cout << "无等级" << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

while 循环：

int a = 10;
while (a < 16)
{
	cout << "a = " << a << endl;
	a++;
}
1
2
3
4
5
6

do while 循环：输出所有的“水仙花数

水仙花数：一个三位数其各位数字的立方和等于该数本身，例如153是“水仙花数”，因为：153 = 1^3 + 5^3 + 3^3

#include
using namespace std;
#include
int main()
{
	int num = 100;
	do
	{
		int a = pow(num % 10, 3); //num对10取余拿到num的个位数
		int b = pow(num / 10 % 10, 3);//num除10再对10取余拿到num的十位数
		int c = pow(num / 100, 3);//num除100拿到num的百位数
		if (a + b + c == num)
		{
			cout << num << endl;
		}
		num++;
	} while (num < 1000);

	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

运行结果：153 370 371 407

for 循环

敲桌子：在一个1-100循环报数中，当数字是7的倍数或个位是7或十位是7，输出敲桌子来替代数字原有的值输出

#include
using namespace std;

int main()
{
	for (int a = 1;a<=100;a++)
	{
		if (a % 7 == 0 || a % 10 == 7 || a / 10 == 7) {
			cout << a << "敲桌子" << endl;
		}
	}
	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

嵌套循环

乘法口诀表：

#include
using namespace std;


int main()
{
	//九九乘法表
	for (int i = 1;i<10;i++)
	{
		for (int j = 1; j <= i; j++)
		{
			cout << j << "*" << i <<"="<< i * j << " ";
		}
		cout << "\n";
	}
	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

break和continue的区别

break退出整个循环，

continue退出本次循环，执行下一次循环

5、数组

一维数组

定义一维数组：

int arr1[] = { 1,2,3,4,5,6 }
1

int arr1[] = { 1,2,3,4,5 };
cout << sizeof(arr1) << endl;// 数组内存 20
cout << arr1 << endl;//数组首地址
1
2
3

冒泡排序：

int arr[] = { 24,3,156,34,324,256,76,87 };
int temp = 0;
for (int i = size(arr)-1; i >0 ; i--)
{
	for (int j = 0; j < i; j++)
	{
		if (arr[j]< arr[j + 1]) {
			temp = arr[j + 1];
			arr[j + 1] = arr[j];
			arr[j] = temp;
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

二维数组

	//定义
	int arr[3][4] = { 
		{10,10,10,10}, 
		{60,70,80,80},
		{50,90,10,10} 
	};
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			cout << arr[i][j] << "  ";
		}
		cout << endl;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

6、函数

函数定义和调用

#include
using namespace std;

// 函数声明
int maxNum(int num1, int num2);

// 函数定义，形参num1，num2
int maxNum(int num1, int num2)
{
	return num1 > num2 ? num1 : num2;
}

int main()
{
	//调用函数，实参10，20
	int num = maxNum(10, 20);//值传递
	cout << num << endl;
	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

函数的声明：

• 由于编译器是一条一条执行的，如果自定义函数在main()函数之后，我们又不加上声明，则会报错，无法找到自定义函数。

• 如果把自定义函数写在调用它的函数之后，则需在调用之前，声明一下自定义函数。

• 声明可以多次，而定义只能一次。

函数的分文件书写，让代码结构更清晰

创建后缀名为.h的头文件，用来写函数的声明；

创建后缀名为.cpp的源文件，用来定义函数。

7、指针

指针是一个变量，其值为另一个变量的地址

定义指针

数据类型 * 指针变量名
1

int a = 10;
//定义指针
int * p;
//让指针p指向a，记录变量a的地址，
p = &a;
cout << &a << endl;
cout << p << endl;
1
2
3
4
5
6
7

00000096B58FF924
00000096B58FF924
1
2

使用指针

通过使用解引用的方式找到指针指向的内存，然后操作内存中的值

int a = 10;
//定义指针
int * p;
//让指针p指向a，记录变量a的地址，
p = &a;
//解引用 *p,获得内存中的值
cout << *p << endl;
//修改指针指向的内存中的值
*p = 100;
cout << *p << endl;
cout << a << endl;
1
2
3
4
5
6
7
8
9
10
11

10
100
100
1
2
3

指针占用的内存

在32位操作系统中，指针占4个字节，不论什么类型

在64位操作系统中，指针占8个字节，不论什么类型

空指针，野指针

空指针：

• 空指针指向内存中编号为0的空间

• 用途：初始化指针变量

• 注意：空指针是不可以访问的

野指针：

• 指针变量指向非法的内存空间
• 不可操作，操作会报错

const修饰

常量指针：const修饰指针 const int * p = &a;

• 指针的指向可以修改

• 指针指向的内存值不可修改

int a = 10;
int b = 30;
//定义指针
int * p;
//常量指针
const int * p = &a;
//修改指向的内存值为30，不允许
*p = 30; 
//修改为指向变量b的地址，允许
p = &b; 
1
2
3
4
5
6
7
8
9
10

指针常量：const修饰常量 int * const p = &a;

• 指针的指向不可以修改

• 指针指向的内存值可修改

int a = 10;
int b = 30;
//定义指针
int * p;
// 指针常量
int * const p = &a;
//修改指针指向的内存值，允许
*p = 30; 
//修改指针指向变量b，不允许
p = &b; 
1
2
3
4
5
6
7
8
9
10

const既修饰指针，又修饰常量：

const int * const p = &a;
1

• 指针的指向和指针指向的内存值都不可以修改

指针访问数组元素

int arr[] = { 1,2,3,4,5,6,7,8,9 };
int* p = arr;//指针指向数组首地址

//利用指针遍历数组
for (int i = 0; i < size(arr); i++)
{
	cout << *p << endl;
	p++;
}
1
2
3
4
5
6
7
8
9

地址传递

#include
using namespace std;

void swap(int * p1, int * p2)
{
	int temp = * p1;
	* p1 = * p2;
	* p2 = temp;
}

int main()
{
	int a = 10;
	int b = 20;
	//把变量a和b的地址交换
	swap(&a, &b);
	cout << a << endl;
	cout << b << endl;
	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

指针，数组，函数使用实例：

#include
using namespace std;
/*
  参数1 数组的首地址
  参数2 数组的长度
*/
void bubbleSort(int * arr, int len)
{
	for (int i = 0; i < len-1; i++)
	{
		for (int j = 0; j < len-i-1; j++)
		{
			if (arr[j]>arr[j+1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}
/*
  参数1 数组
  参数2 数组的长度
*/
void bubbleSort1(int arr[], int len)
{
	for (int i = 0; i < len - 1; i++)
	{
		for (int j = 0; j < len - i - 1; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}
int main()
{
	int arr[] = { 2,1,6,9,3,5,0,8 };
	//bubbleSort(arr, size(arr));
	bubbleSort1(arr, size(arr));
	for (int i = 0; i < len; i++)
	{
		cout << arr[i] << endl;
	}
	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

8、结构体

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

结构体定义

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

//定义结构体
struct Studrnt 
{
	string name;
	int age;
	string sex;
};
1
2
3
4
5
6
7

创建结构体对象

#include
using namespace std;

//定义结构体
struct Student
{
	string name;
	int age;
	string sex;
}s3;//方式三：定义结构体时创建

int main()
{
    //方式一：创建结构体对象时struct可以省略
	Student s1;
	s1.name = "方唐镜";
	s1.age = 18;
	s1.sex = "男";

    //方式二：
	struct Student s2 = { "王五",23,"男"};

	s3.name = "神明";
	s3.age = 28;
	s3.sex = "男";

	cout << "学生姓名:" << s1.name << " 年龄：" << s1.age << " 性别：" << s1.sex << endl;
	cout << "学生姓名:" << s2.name << " 年龄：" << s2.age << " 性别：" << s2.sex << endl;
	cout << "学生姓名:" << s3.name << " 年龄：" << s3.age << " 性别：" << s3.sex << endl;

	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

结构体数组

将结构体放在数组中，便于管理

//定义结构体
struct Student
{
	string name;
	int age;
	string sex;
};

int main()
{

    //创建结构体数组
	struct Student stuArr[3] = {
		{"张三",24,"男"},
		{"李四",23,"男"} ,
		{"王五",84,"男"}
	};
	//改结构体数组的元素
	stuArr[2].name = "赵六";
	stuArr[2].age = 30;
	stuArr[2].sex = "男";

	for (int i = 0; i < 3; i++)
	{
		cout << "姓名：" << stuArr[i].name << "年龄:" << stuArr[i].age << "性别:" << stuArr[i].sex << endl;
	}

	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

结构体指针

通过结构体指针访问结构体属性，需要利用->

//定义结构体
struct Student
{
	string name;
	int age;
	int score;
};

int main()
{
	Student stu = { "王五",84,100 };
	//通过指针指向结构体对象
	Student * p = &stu;
	//通过结构体指针访问结构体属性
	cout << "姓名：" << p->name << " 年龄 " << p->age << " 分数 " << p->score << endl;
	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

结构体嵌套

结构体里的属性包含一个或多个结构体

//定义结构体
struct Student
{
	string name;
	int age;
	int score;
};
struct Teacher {
	int id;
	string name;
	int age;
	struct Student stu;
};

int main()
{
	Teacher t;
	t.id = 10000;
	t.name = "老王";
	t.age = 60;
	Student s1 = { "王五",84,100 };
	t.stu = s1;

	cout << "老师id " << t.id << " 老师姓名 " << t.name << " 老师年龄 " << t.age <<
		" 学生姓名: " << t.stu.name << " 学生年龄 " << t.stu.age
		<< " 学生成绩 " << t.stu.score << endl;
	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

结构体做函数参数

值传递，地址传递

//定义结构体
struct Student
{
	string name;
	int age;
	int score;
};

//打印学生信息的函数1
void printlnStu1(struct Student s1) {
	s1.score = 100;
	cout << " printlnStu1学生姓名: " << s1.name << " 学生年龄 " << s1.age
		<< " 学生成绩 " << s1.score << endl;
}
//打印学生信息的函数2
void printlnStu2(struct Student * p) {
	p->score = 100;
	cout << " printlnStu2学生姓名: " << p->name << " 学生年龄 " << p->age
		<< " 学生成绩 " << p->score << endl;
}

int main()
{
	//创建结构体
	Student s2 = { "王五",24,88 };
	//值传递，形参(s1)的值改变了（s1.score = 100;），实参(s2)的值不会变
	printlnStu1(s2);
	cout << " 学生姓名: " << s2.name << " 学生年龄 " << s2.age
		<< " 学生成绩 " << s2.score << endl;
	//地址传递，形参的值改变了（s1.score = 100;），实参的值也变
	printlnStu2(&s2);
	cout << " 学生姓名: " << s2.name << " 学生年龄 " << s2.age
		<< " 学生成绩 " << s2.score << endl;

	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

结构体const使用场景

在将指针作为函数的参数时，可以添加const修饰，只可以读取地址的值，不能改数据，防止误操作。

//定义结构体
struct Student
{
	string name;
	int age;
	int score;
};
//打印学生信息
void printlnStu(const struct Student s1) {
	//s1.score = 100;  不能改数据，防止误操作
	cout << " 学生姓名: " << s1.name << " 学生年龄 " << s1.age
		<< " 学生成绩 " << s1.score << endl;
}
int main()
{
	//创建结构体
	Student s1 = { "王五",24,88 };
	//地址传递,将函数中的参数改为指针，可以减少内存空间
	printlnStu2(&s1);
	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22