C++学习记录--基础

程序流程结构

三种程序运行结构：顺序结构、选择结构、循环结构

选择结构–if语句

单行、多行、多条件（if…else if…else if…else)

三目运算符

表达式1 ？ 表达式2 ： 表达式3
说明：如果表达式1的值为真，执行表达式2，并返回表达式2的结果；如果表达式1的值为假，执行表达式3，并返回表达式3的结果。
三目运算符返回的是变量，可以继续赋值，如：(a > b? a:b) = 100;

选择结构–switch语句

switch（语句）
{
Case 10: … ;break;
…
Default;
}
注意：
1.switch语句中表达式类型只能是整型或者字符型；
2.case里如果没有break，那么程序会一直向下执行（case1:case2:case3:…)；
与if语句相比，对于多条件判断时，switch的结构清晰，窒息你个效率高，缺点是switch不可判断区间。

循环语句–while

在执行循环语句的时候，程序必须提供跳出循环的出口，否则出现死循环。利用break可以退出while(1)死循环。
生成随机数，需要添加随机数种子，利用当前系统时间生成随机数，防止每次随机数一样。
#include
Srand ((unsigned int)time(NULL));
Num = rand()%1000;//1-1000随机数

循环语句–do…while

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

循环语句–for循环

For(int i=0;i<5;i++){…}

void Multiplication_Table() {
    
    
	//乘法表-->
	int temp;
	cout << "乘法表:" << endl;
	for (int i = 1; i <= 9; i++) {
    
    
		for (int j = 1; j <= i; j++) {
    
    
			temp = i * j;
			cout << j << " x " << i << " = " << temp <<"\t";
		}
		cout << endl;
	}
}

嵌套循环

外层执行一次，内层执行一周。

跳转语句–break

用于跳出选择结构或循环结构。如switch（选择）、if（选择）、while（循环）、for（选择）、嵌套循环（跳出内循环）。
注：如果循环结构包含选择结构，在选择结构中使用break，可以跳出循环结构（退出循环）。

扫描二维码关注公众号，回复： 12447464 查看本文章

跳转语句–continue

执行到本行，就不执行后面的代码，而执行下一次循环，不会退出循环。（可以用于筛选条件）

跳转语句–goto

不常用。

数组

特点1：数组中的每个数据元素都是相同的数据类型；
特点2：数组是由连续的内存位置组成的。

一维数组

数组名的用途：可以统计整个数组在内存中的长度；可以获取数组在内存中的首地址。
数组名是常量，不能赋值操作。
定义方式

1. 数据类型 数组名 [数组长度]；
2. 数据类型 数组名 [数组长度] = {值1，值2，…}；
3. 数据类型 数组名 [ ] = {值1，值2…}。

void Array() {
    
    
	int a1, a2, b1;
	int arr[5] = {
    
     1,3,2,4,5 };
	a1 = sizeof(arr[0]);//单个元素占用空间
	a2 = sizeof(arr);//数组总空间
	b1 = a2 / a1;
	cout << "数组元素个数为： " << b1 << endl;
	cout << "数组首地址为：" << (int)arr << endl;
	cout << "数组第一个元素首地址：" << (int)&arr[0] << endl;
	cout << "数组第一个元素首地址：" << (int)&arr[1] << endl;
	//实现元素逆置-->
	cout << "数组元素逆置前:" << endl;
	for (int i = 0; i < b1; i++) {
    
    
		cout << arr[i] << "\t";
	}
	cout << endl;
	int start = 0;//起始下标
	int end = b1 - 1;//结束下标
	while (start < end) {
    
    
		int temp = arr[start];
		arr[start] = arr[end];
		arr[end] = temp;
		start++;
		end--;
	}
	cout << "数组元素逆置后:" << endl;
	for (int i = 0; i < b1; i++) {
    
    
		cout << arr[i] << "\t";
	}
	cout << endl;
}
void Bubble_Sort() {
    
    
	//冒泡排序-->
	int arr[] = {
    
     8,12,45,10,23,40,56,78,62,31,100 };
	int Num = sizeof(arr) / sizeof(arr[0]);
	int Num1 = Num;
	cout << "原始数据：" << endl;
	for (int i = 0; i < Num; i++) {
    
    
		cout << arr[i] << "\t";
	}
	cout << endl;
	//排序算法-->
	//while(Num1 > 1){
    
    
	//	for (int i = 0; i < Num1; i++) {
    
    
	//		if (arr[i] < arr[i + 1]) {
    
    
	//			int temp = arr[i];
	//			arr[i] = arr[i + 1];
	//			arr[i + 1] = temp;
	//		}
	//	}
	//	Num1--;
	//}
	//<--排序算法 or 排序算法-->
	for (int i = 0; i < Num - 1; i++) {
    
    
		for (int j = 0; j < Num - i - 1; j++) {
    
    
			if (arr[j] < arr[j + 1]) {
    
    
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
	//<--排序算法
	cout << "从大到小：" << endl;
	for (int i = 0; i < Num; i++) {
    
    
		cout << arr[i] << "\t";
	}
	cout << endl;
}

二维数组

…

函数

值传递：当函数值传递时，函数的形参发生改变，并不会影响实参。
常见函数形式：
无参无返；有参无返；无参有返；有参有返。

函数的分文件编写

让代码结构更清晰，一般有四步：

1. 创建后缀名为.h的头文件；
2. 创建后缀名为.cpp的源文件；
3. 在头文件中写函数的声明；
4. 在源文件中写函数的定义。

指针

可以通过指针保存地址。

1. 指针的定义：
   数据类型 * 指针变量名
2. 使用指针：
   可以通过解引用的方式找到指针指向的内存中的数据。*p 表示解引用。

指针占用的内存空间

32位系统下，指针都是占用4个字节内存；64位系统下指针都是占用8个字节。（无论 char、int、float、double等）

int main{
    
    
ina a = 10;
int * p = &a;
cout << "sizeof (int *) = " << sizeif(int *) <<endl;
cout << "sizeof (int *) = " << sizeif(float *) <<endl;
//int * 是一种指针类型，或者说是数据类型，作为一个整体存在。
system("pause");
return 0;
}

空指针和野指针

空指针：指针变量指向内存中编号为0的空间。
用途：初始化指针变量。
注意：空指针指向的内存不可访问，0-255之间的内存编号是系统占用的，因此不可访问。

int * p = NULL;//初始化

野指针：指针变量指向非法的内存空间。

int * p = (int *)0x1100;//野指针，无法访问该地址内存

总结：空指针和野指针都不是我们申请的内存空间，因此不要访问。

const 修饰指针

分为三种情况：

1. const修饰指针 – 常量指针；
2. const修饰常量 – 指针常量；
3. const即修饰指针，又修饰常量。

int a = 10;
int b = 10;
int *p = &a;
const int * p = &a;//常量指针，特点：指针指向可以修改，但是指针指向的值不可以修改。
int * const p = &a;//指针常量，指针的指向不可以改，指针指向的值可以改。
const int * const p = &a;//指针的指向和指针指向的值都不可以改。

指针和数组

利用指针访问数组中的元素。

int arr[10] = {
    
    1,2,3,4,5,6,7,8,9,10};
cout <<"First Number: " << arr[0] << endl;
int * p = arr;//指针指向首地址
cout << "Prt First Number: " << *p << endl;
p++;
cout << "Prt Second Number: " << *p <<endl;
int * p2 = arr;
for (int i = 0; i<10;i++){
    
    
cout << *p2 << endl;
p2++;
}

指针和函数

作用：利用指针作为函数参数，可以修改实参的值。

结构体

属于用户自定义的数据类型，允许用户储存不同的数据类型。
创建方式：

1. struct 结构体名 变量名
2. struct 结构体名 变量名 = {成员，成员}
3. 定义结构体时顺便创建变量。
   注：结构体定义时，struct 不可以省略；结构体变量创建时，struct 可以省略。

结构体数组

作用：将自定义的结构体放入到数组中方便维护。

struct Student
{
    
    
	string name;
	int age;
	int score;
};
	Student StuArray[3] = 
	{
    
    
		{
    
    "张三",18,100},
		{
    
    "李四",28,80},
		{
    
    "王五",20,68},
	};

结构体指针

采用 -> 访问结构体指针。

//1.创建结构体变量
Student s = {
    
    "张三",18,100};
//通过指针指向结构体变量
Student * p = &s;
p -> age = 20;

结构体做函数参数

作用：将结构体作为参数向函数中传递。
传递方式：值传递和地址传递。
注意值传递和地址传递的区别。如果不想修改主函数中的数据，用值传递，反之用地址传递。

void PrintfStu1(struct Student stu)//结构体值传递
{
    
    
	cout << " 值传递，name: " << stu.name << '\t'
		<< " age: " << stu.age << '\t'
		<< " score: " << stu.score << endl;
};
void PrintfStu2(struct Student * stu)
{
    
    
	cout << " 地址传递，name: " << stu->name << '\t'
		<< " age: " << stu->age << '\t'
		<< " score: " << stu->score << endl;
};

const使用场景

将函数中的形参改为指针，可以减少内存空间。而且不会复制新的副本出来。为了避免指针对实参修改可采用const修饰，防止误操作。

void PrintStu(const Student *stu)
{
    
    
	...
}