C++笔记打卡第五天（指针、结构体）

1.指针

int a = 10;
// 指针定义的语法：数据类型 * 指针变量名
int* p;
p = &a;
// 也可以直接定义为： int* p = &a
cout << &a << endl;
cout << p << endl;

// 可以通过解引用的方式来找到指针指向的内存（可以修改a的值）
*p = 1000;
cout << *p << endl;
cout << a << endl;

2.指针所占的内存空间

• 在32位操作系统下，占用4个字节空间
• 在64位操作系统下，占用8个字节空间

cout << sizeof(*p) << endl;  // 4
cout << sizeof(p) << endl;  // 4 or 8

3.空指针和野指针

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

  • 初始化指针变量
  • 空指针指向的内存是不可以访问

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

• 空指针和野指针都不是我们自己申请的空间，因此不要访问

4.const修饰指针

• const 修饰指针—— 常量指针：指针的指向可以修改，但指针指向的值不可以修改

  eg: const int* p = &a;

  *p = 20； 错误，指针指向的值不能修改

  p = &b； 正确，指针指向可以修改

• const 修饰常量——— 指针常量：指针的指向不可以修改，但指针指向的值可以改

  eg： int* const p = &a;

  *p = 20； 正确，指针指向的值能修改

  p = &b； 错误，指针指向不可以修改

• const 既修饰指针，也修饰常量：指针的指向不可以修改，指针指向的值也不可以改

  eg：const int * const p = &a;

  *p = 20； 错误，指针指向的值不可以修改

  p = &b； 错误，指针指向不可以修改

5.指针和数组

int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = arr;
cout << *p << endl;  // 访问第一个元素
p++;  // 让指针向后偏移4个字节
cout << *p << endl;  // 访问第二个元素

int* p2 = arr;  // 循环遍历数组
for (int i = 0;i < 10;i++)
{
	cout << *p2 << endl;
	p2++;
}

6.指针和函数

void swap01(int num1, int num2)
{
	int temp = num1;
	num1 = num2;
	num2 = temp;
}
void swap02(int *p1, int *p2)
{
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}
int main()
{   
	// 1.值传递
	int a = 10;
	int b = 20;
	swap01(a, b);
	cout << "01a = " << a << endl;  // 10
	cout << "01b = " << b << endl;  // 20
	// 2.地址传递
	// 如果是地址传递，可以修饰实参!!!!
	swap02(&a, &b);
	cout << "02a = " << a << endl;  // 20
	cout << "02b = " << b << endl;  // 10

如果不想修改实参，就用值传递；如果想修改实参，就用地址传递。

7.指针、数组、函数

封装一个函数，利用冒泡排序，实现对一个整型数组的升序排列

！注意数组是怎么传进函数的

// 数组的首地址，数组的长度
void swap01(int *arr, int length)
{
	for (int i = 0;i < length - 1;i++)
	{
		for (int j = 0;j < length - 1 - i;j++)
		{
			if (arr[j] > arr[j+1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}

void printArray(int* arr, int length)
{
	for (int k = 0;k < length;k++)
	{
		cout << arr[k] << endl;
	}
}

int main()
{   
	int arr[] = { 4,3,6,9,1,2,10,8,7,5 };
	int length = sizeof(arr) / sizeof(arr[0]);
	swap01(arr, length);
	printArray(arr, length);
	system("pause");
	return 0;
}

8.结构体

• 结构体属于用户自定义的数据类型，允许用户存储不同的数据类型
• 三种定义方式（创建变量时struct 可以省略）：
  • struct 结构体名 变量名
  • struct 结构体名 变量名 = {成员1值，成员2值，…}
  • 定义结构体时顺便创建变量
• 结构体变量利用操作符 . 来访问其中的成员

// 自定义数据类型：一些类型集合组成的一个类型
struct Student
{
	// 成员列表
	string name;
	int age;
	int score;
}s3;  // 可以在定义时，就顺便创建一个结构体变量（不常用）

int main()
{   
	struct Student s1;  // 创建变量时struct 可以省略
	s1.name = "张三";
	s1.age = 18;
	s1.score = 100;

	struct Student s2 = {"李四", 19, 80};
	system("pause");
	return 0;
}

9.结构体数组

• 将自定义的结构体放入到数组中方便维护（赋值更方便）

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

int main()
{   
	struct Student stuArray[3] =
	{
		{"张三", 18, 100},
		{"李四", 19, 80},
		{"王五", 20, 60}
	};
	stuArray[2].name = "赵六";
	stuArray[2].age = 30;
	stuArray[2].score = 70;

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

10.结构体指针

• 结构体指针利用操作符 - >访问结构体变量

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

int main()
{   
	struct Student s = { "张三", 18 ,100 };
	struct Student* p = &s;
	// 通过结构体指针 访问结构体变量，需要利用 ->
	cout << "姓名：" << p->name 
		<< " 年龄：" << p->age 
		<< " 分数：" << p->score 
		<< endl;
	system("pause");
	return 0;
}

11.结构体嵌套结构体

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

struct teacher
{
	int id;
	string name;
	int age;
	struct student stu; // 必须在前面定义好
};

int main()
{   
	struct teacher t;
	t.id = 100;
	t.name = "老王";
	t.age = 50;
	t.stu.name = "小王";
	t.stu.age = 20;
	t.stu.score = 100;
	
	cout << "老师姓名：" << t.name
		<< " 老师年龄：" << t.age
		<< " 学生姓名：" << t.stu.name
		<< " 学生年龄：" << t.stu.age
		<< endl;
	system("pause");
	return 0;
}

12.结构体做函数参数

struct student
{
	string name;
	int age;
	int score;
};
// 值传递
void printStudent1(struct student s)
{
	cout << "子函数1中 姓名：" << s.name << " 年龄：" << s.age << " 分数：" << s.score << endl;
}
// 地址传递
void printStudent2(struct student* p)
{
	cout << "子函数2中 姓名：" << p->name << " 年龄：" << p->age << " 分数：" << p->score << endl;
}

int main()
{   
	// 将学生传入到一个参数中，打印学生身上的所有信息
	struct student s;
	s.name = "张三";
	s.age = 18;
	s.score = 100;
	printStudent1(s);
	printStudent2(&s);
	system("pause");
	return 0;
}

13.结构体集中const使用场景、

• 加入const后不能修改s，可以防止我们的误操作

struct student
{
	string name;
	int age;
	int score;
};
// 将函数中的形参改为指针，可以减少内存空间，而且不会复制新的副本出来
void printStudent(const student *s)
{
	// s->age = 150; 加入const后不能修改s，可以防止我们的误操作
	cout << "姓名：" << s->name << " 年龄：" << s->age << " 分数：" << s->score << endl;
}
int main()
{   
	struct student s = { "张三", 15, 100 };
	printStudent(&s);
	
	system("pause");
	return 0;
}