目录
1, 什么是指针
指针就是存储地址的变量, 指针就是地址
2, 指针定义
通过数据类型 * 指针变量名, 可定义一个指针变量, 指针数据类型需要和变量数据类型一致
int a = 10;
//定义指针变量p, 指向变量a的地址
int * p = &a;
3, 通过指针修改变量
通过*指针变量名=值, 可操作指针指向的变量值
#include <iostream>
using namespace std;
int main()
{
int a = 10;
//定义指针变量p, 指向变量a的地址
int * p = &a;
cout << "a的地址:" << &a << endl;
cout << "指针p的地址:" << p << endl;
//通过指针修改变量的值
*p = 1000;
cout << "a的值:" << a << endl;
cout << "*p的值:" << *p << endl;
system("pause");
return 0;
}
-------------------------------------------------------
输出结果:
a的地址:00000096422FFB34
指针p的地址:00000096422FFB34
a的值:1000
*p的值:1000
4, 指针占用内存大小
指针占用内存大小与指针类型没有关系, 与操作系统有关系, 32位系统占用4字节, 64位系统占用8字节
#include <iostream>
using namespace std;
int main()
{
cout << "int型指针占用内存大小:" << sizeof(int *) << endl;
cout << "float型指针占用内存大小:" << sizeof(float *) << endl;
cout << "double型指针占用内存大小:" << sizeof(double *) << endl;
cout << "char型指针占用内存大小:" << sizeof(char *) << endl;
cout << "string型指针占用内存大小:" << sizeof(string *) << endl;
system("pause");
return 0;
}
--------------------------------------------------------------
输出结果:
int型指针占用内存大小:4
float型指针占用内存大小:4
double型指针占用内存大小:4
char型指针占用内存大小:4
string型指针占用内存大小:4
5, 空指针
4-1, 什么是空指针
地址为0的指针为空指针, 用于指针变量初始化,空指针不能访问
4-2, 定义空指针
通过数据类型 * 指针变量名 = NULL, 可定义一个空指针
//定义p为一个空指针
int * p = NULL;
6, 野指针
指向一个未知的地址的指针,叫着野指针, 访问该地址会出错
//定义p为一个野指针
//因为地址0x1100是未知的
//(int*)0x1100表示将0x1100转换为int类型指针
int * p = (int *)0x1100;
7, const修饰指针
7-1, 指针常量
通过数据类型 * const 指针变量名称, 可定义一个指针常量, 指向不能修改, 指向的变量值可修改
#include <iostream>
using namespace std;
int main()
{
int a = 10;
int b = 20;
//定义p为一个指针常量
int * const p = &a;
//指针常量是不能修改指向的,所以下面的不正确
//p = &b;
//指针常量可以修改指向的值
*p = 100;
cout << "a的值:" << a << endl;
cout << "*p的值:" << *p << endl;
system("pause");
return 0;
}
--------------------------------------------------------------
输出结果:
a的值:100
*p的值:100
7-2, 常量指针
通过const 数据类型 * 指针变量名称, 可定义一个常量指针, 指向能修改, 指向的变量值不能修改
#include <iostream>
using namespace std;
int main()
{
int a = 10;
int b = 20;
//定义p为一个常量指针
const int * p = &a;
//常量指针是不能修改值的,所以下面的不正确
//*p = 100;
//常量指针可以修改指向的值
p = &b;
cout << "a的值:" << a << endl;
cout << "*p的值:" << *p << endl;
system("pause");
return 0;
}
---------------------------------------------------------------
输出结果:
a的值:10
*p的值:20
7-3,即修饰常量又修饰指针
通过const 数据类型 * const 指针变量名, 可即修饰常量又修饰指针, 该方式修饰的指针,指向和指向的值都不能修改
#include <iostream>
using namespace std;
int main()
{
int a = 10;
int b = 20;
//定义p为一个常量指针
const int * const p = &a;
//不能修改指向值,所以下面的不正确
//*p = 100;
//不能修改指向, 所以下面的不正确
//p = &b;
cout << "a的值:" << a << endl;
cout << "*p的值:" << *p << endl;
system("pause");
return 0;
}
-------------------------------------------------------
输出结果:
a的值:10
*p的值:10
8, 指针访问数组
#include <iostream>
using namespace std;
int main()
{
int attr[] = {1, 2, 3, 4, 5, 6};
//将数组的首地址赋值给指针p
int * p = attr;
cout << "通过指针访问数组元素:" << endl;
for (int i = 0; i < 6; i++)
{
cout << *p << endl;
//p++每次移动到数组的下个元素
p++;
}
system("pause");
return 0;
}
----------------------------------------------------
输出结果:
1
2
3
4
5
6
9, 指针当着函数参数
当指针做为函数实参,调用函数后,实参的值也会发生变化
#include <iostream>
using namespace std;
void swap(int * p1, int * p2)
{
int tmp = 0;
tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
int main()
{
int a = 10;
int b = 20;
int * p1 = &a;
int * p2 = &b;
//指针作为实参传递
swap(p1, p2);
cout << "a=" << a << endl;
cout << "b=" << b << endl;
system("pause");
return 0;
}
---------------------------------------------------------
输出结果:
a=20
b=10
10, 通过指针实现冒泡排序
#include <iostream>
using namespace std;
void bubble_sort(int * attr, int len)
{
int tmp = 0;
for (int i=0; i<len-1; i++)
{
for (int j=0; j<len-i-1; j++)
{
if (attr[j]>attr[j+1])
{
tmp = attr[j];
attr[j] = attr[j+1];
attr[j+1] = tmp;
}
}
}
}
void print_sort_attr(int * attr, int len)
{
cout << "排序后的数组为:" << endl;
for (int i = 0; i < len; i++)
{
cout << attr[i] << " ";
}
cout << endl;
}
int main()
{
int attr[] = { 4, 3, 6, 9, 1, 2, 10, 8, 7, 5 };
int attr_len = sizeof(attr) / sizeof(attr[0]);
int * p = attr;
bubble_sort(p, attr_len);
print_sort_attr(p, attr_len);
system("pause");
return 0;
}
----------------------------------------------------
输出结果:
1 2 3 4 5 6 7 8 9 10