C++学习记录（二）

7.5 const修饰指针

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

int a = 10;
int b = 10;
int * p = & a

// 常量指针
const int * p = & a
// 常量指针的指向可以修改，但是指针指向的值不可以修改
* p = 20; //错误写法，*p指向的值不能改
p = &b; //正确写法，p指针的指向可以修改
1
2
3
4
5
6
7
8
9

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

int * const p = &a;
//指针常量：指针的指向不可以修改，指针指向的值可以修改
*p = 20; //正确写法，指针常量，指针指向的值可以修改，指针的指向不可以修改
p = &b;// 错误写法，指针常量，指针的指向不可以修改
1
2
3
4

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

const int * const p = &a;
特点：指针的指向和指针指向的值不可以改
* p =20; //错误
p = &b; //错误
1
2
3
4

7.6 指针和数组

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

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;
p++; //两种写法
1
2
3
4
5
6
7
8
9
10
11

7.7 指针和函数

作用：利用指针做函数参数，可以修改实参的值
示例：

// 值传递
void swap1(int a, int b)
{
	int temp = a;
	a = b;
	b = tmp;
	cout << "swap "<< a << endl; //20
	cout << "swap"<< b << endl; //10
}
a = 10;
b = 20;
swap1(a, b) //实参没有变
cout << "a"<< a << endl; //10
cout << "b"<< b << endl; //20

//地址传递
void swap2(int *p1, int *p2)
{
	int temp = *p1;
	*p1 = *p2;
	*p2 =temp;
}	//地址传递会修改实参
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

7.8 指针、数组、函数

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

//冒泡排序函数
void bubbleSort(int *arr, int len) //int *arr 也可写成int arr[]
{
	for (int i=0; i<len-i;i++)
	{
		for (int j=0;j<len-1-i;j++)
		{
			if(arr[j]>arr[j+1])
			{
				int tmp = arr[j];
				arr[j] = arr[j+1]
				arr[j+1] = tmp
			}
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16