c++学习07指针

指针

定义的语法

数据类型 * 指针变量名

使用指针

可以通过解引用的方式找到指针指向的内存
指针前加*号表示解引用，找到指针指向的内存数据

#include <iostream>
using namespace std;
int main() {

	//指针的定义和使用
	int a = 20;
	int* p;
	p = &a;
	cout << "a的地址为" << &a << endl;
	cout << "a的地址为" << p << endl;

	*p = 1000;
	cout << "a的值为" << a << endl;
	cout << "*p的值为" << *p << endl;
	
	system("pause");
	return 0;
}

指针占用的内存

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

#include <iostream>
using namespace std;
int main() {

	//指针所占的内存大小
	int a = 800;
	int *p = &a;

	cout << "(int *) 所占的内存大小" <<sizeof(int*) << endl;
	cout << "(int *) 所占的内存大小" <<sizeof(p) << endl;
	cout << "(float *) 所占的内存大小" <<sizeof(float *) << endl;
	cout << "(double *) 所占的内存大小" <<sizeof(double *) << endl;
	cout << "(char *) 所占的内存大小" <<sizeof(char *) << endl;
	

	system("pause");
	return 0;
}

输出结果

x64

x86

空指针

空指针指向内存中编号为0的空间
空指针用于给指针变量初始化
空指针是不可以访问的
（0-255之间的内存是系统占用的，不可以访问）

野指针

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

const修饰指针

const修饰指针有3种情况：

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

不被修饰的情况;
int a = 20;
int b = 30;
int *p = &a; 
*p = 100; //✔
p = &b; //✖

常量指针

特点：
指针的指向可以修改
指针的值不可修改

int a = 20;
int b = 30;
const int * p = &a;
*p = 30; //✖
p = &b; //✔

指针常量

特点：
指针的指向不可以修改
指针的值可以修改

int a = 20;
int b = 30;
int * const p = &a;
*p = 30; //✔
p = &b; //✖

3

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

int a = 20;
int b = 30;
const int * const p = &a;
*p = 30; //✖
p = &b; //✖

指针和数组

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

#include<iostream>
using namespace std;
int main() {

	//指针和数组
	//利用指针访问数组

	int a[] = { 1,2,3,34,4,5,6,7 };

	cout << "第一个元素为:" << a[0] << endl;
	int* p = a;
	cout << "第一个元素为：" << *p << endl;
	p++; //向后偏移4/8个字节（取决于32位还是64位操作系统）
	cout << "第二个元素为：" << *p << endl;
	p++;
	cout << "第三个元素为：" << *p << endl;

	//利用指针遍历数组

	int* p2 = a;
	for (int i = 0; i < size(a); i++) {
		cout << *p2 << endl;
		p2++;
	}
	system("pause");
	return 0;
}

指针和函数

# include<iostream>
using namespace std;


void swap1(int a,int b) {
	int temp = a;
	a = b;
	b = temp;

	cout << "方法swap1中a的值为：" << a << endl;
	cout << "方法swap1中b的值为：" << b << endl;
}

void swap2(int* p1, int* p2) {
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
	cout << "方法swap2中a的值为：" << *p1 << endl;
	cout << "方法swap2中b的值为：" << *p2 << endl;
}
int main() {
	//指针和函数
	int a = 10;
	int b = 20;

	//值传递
	cout << "值传递：" << endl;
    //值传递不会改变实参
	swap1(a, b);
	cout << "a的值为：" << a << endl;
	cout << "b的值为：" << b << endl;

	//地址传递
	cout << "地址传递：" << endl;
	//地址传递会改变实参的值
	swap2(&a, &b);
	cout << "a的值为：" << a << endl;
	cout << "b的值为：" << b << endl;
	system("pause");
	return 0;
}

输出结果：

指针，数组和函数

案例描述：封装一个函数，对数组进行冒泡排序，实现数组的升序排序

#include<iostream>
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;
			}
		}

	}
}

int main() {
	//创建一个数组
	int arr[] = {2,1,6,9,3,5,0,9};

	bubbleSort(arr, size(arr));

	cout << "冒泡排序后的数组：" << endl;
	for (int i = 0; i < size(arr); i++) {
		cout << arr[i] << "  ";
	}
	cout << endl;
	system("pause");
	return 0;
}

输出结果：