函数

函数定义里小括号内称为形参
函数调用里小括号内称为实参

值传递的时候，形参发生任何的改变，都不会影响实参

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

函数的分文件编写

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

指针

指针占用的内存空间

32位操作系统下，任何类型指针均为4个字节
64位操作系统下，任何类型指针均为8个字节

空指针

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

野指针

定义：指针变量指向非法的内存空间

const修饰指针

1.const修饰指针——常量指针

const int *p1 = &a;

指针指向的值不可以修改，指针的指向可以修改

*p1 = 20;		//错误
p1 = &b;		//正确

2.const修饰常量——指针常量

int * const p2 = &a;

指针的指向不可以修改，指针指向的值可以修改

p2 = &b;		//错误
*p2 = 20;		//正确

3.const既修饰指针，又修饰常量

const int * const p3 = &a;

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

指针和数组

int arr[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
int *p = arr;		//arr就是数组首地址

利用指针遍历数组

int *p2 = arr;
for (int i = 0; i < 10; i++) {
	cout << *p2 << endl;
	p2++;
}

函数中的值传递和地址传递

int a = 10, b = 20;

值传递

void swap1(int x, int y)
{
	int temp;
	temp = x;
	x = y;
	y = temp;
}

值传递不会改变实参的值

	swap1(a, b);
	cout << "a = " << a << "; b = " << b << endl;

地址传递

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

地址传递 会改变实参的值

	swap2(&a, &b);		
	cout << "a = " << a << "; b = " << b << endl;

结构体

结构体定义

struct Student {
	string name;
	int age;
	int score;
};

数组：

Student StuArray[] = { {"费沁源", 21, 16 }, {"王奕", 21, 9 }, {"周诗雨", 24, 12} };

指针：

Student s1 = { "宋雨珊", 23, 40 };
Student *p = &s1;

Student *q = &StuArray[0];

Student *stu = { 0 };
stu[0] = { "沈梦瑶", 24, 3 };

值传递

void printStu1(Student s)
{
	cout << "printStu1_值传递" << endl;
	cout << s.name << " " << "age:" << s.age << " score:" << s.score << endl;
}

printStu1(s1);

地址传递

void printStu2(Student *p)
{
	cout << "printStu2_地址传递" << endl;
	cout << p->name << " " << "age:" << p->age << " score:" << p->score << endl;
}

printStu2(&s1);

结构体嵌套

struct Team {
	string t_name;
	struct Student stu;
};

Team H;
H.t_name = "HII";
H.stu.name = "万丽娜";
H.stu = { "冯思佳", 23, 0 };

const修饰结构体

void Stu_const(const Student *p)
{
	p->age = 25;		//错误，const使得值不可以修改，防止误操作
}