目录
调用:两种方式:(*指针名)(参数地址) 或者 指针名(参数地址)
二级指针
二级指针也是一个普通的指针变量，只是它里面保存的值是另外一个一级指针的地址
#include <iostream>
using namespace std;
int main(void) {
int massage = 888;
int* guizi1 = &massage;
int** guizi2 = &guizi1;
cout << "massage的地址" << &massage << endl;
cout << "guizi1内的地址" << guizi1 << endl;
cout << "guizi2内的地址" << *guizi2 << endl;
cout << "guizi1内的值" << *guizi1 << endl;
cout << "guizi2内的值" << **guizi2 << endl;
return 0;
}二级指针和一级指针的类型都是相同的,
二级指针所指向的对象就是一级指针的值,一级指针的值又是指向的变量的值,所以不管有多少级指针,他们只要保存的是上一级指针的地址,那么内部所保存的地址值都是一样的,
这里不要和指针变量本身作为一个变量的指针混淆了,所定义的二级指针和一级指针他们的地址值肯定是不同的但是他们内部所保存的内容(对象的地址)是相同的
二级指针的用途
普通指针可以将变量通过参数“带入”函数内部然后进行修改，但没办法将函数的内部变量“带出”函数
二级指针不但可以将变量通过参数带入函数内部，也可以将函数内部变量 “带出”到函数外部。
使用的一级指针报警:读取位置 0x0000000000000000 时发生访问冲突。这个全部为0的地址就是给一级指针初始化时设的NULL值(空指针，就是值为 0 的指针,任何程序数据都不会存储在地址为 0 的内存块中，它是被操作系统预留的内存块)
#include <iostream>
using namespace std;
void swap(int* a, int* b,int *c) {
int tmp = *a;
*a = *b;
*b = tmp;
int d = *a + *b;
c = &d;
}
void boy(int** meipo) {
static int boy = 22;
*meipo = &boy;
}
int main(void) {
int a = 8;
int b = 3;
int* c = NULL;
swap(&a, &b, c);
cout << "一级指针传入之后c的值:"<<endl;
int* type = NULL;
boy(&type);
cout << "通过二级指针带回来的值:" << *type << endl;
return 0;
}通过程序调用可以看出给二级指针传入地址值后,二级指针可以通过一级指针把函数内部的变量地址值给带回来
多级指针的定义和使用
#include <iostream>
using namespace std;
int main(void) {
int massage = 888;
int* guizi1 = &massage;
int** guizi2 = &guizi1;
int*** guizi3 = &guizi2;
int**** guizi4 = &guizi3;
int***** guizi5 = &guizi4;
cout << "massage的地址" << &massage << endl;
cout << "guizi1内的地址" << guizi1 << endl;
cout << "guizi2内的地址" << *guizi2 << endl;
cout << "guizi3内的地址" << **guizi3 << endl;
cout << "guizi4内的地址" << ***guizi4 << endl;
cout << "guizi5内的地址" << ****guizi5 << endl;
cout << "guizi1内的值" << *guizi1 << endl;
cout << "guizi2内的值" << **guizi2 << endl;
cout << "guizi3内的值" << ***guizi3 << endl;
cout << "guizi4内的值" << ****guizi4 << endl;
cout << "guizi5内的值" << *****guizi5 << endl;
return 0;
}指针和数组之间的关系
#include <iostream>
using namespace std;
void print_1(int days[], int len) {
for (int i = 0; i < len; i++) {
//用数组的方式输出
cout << "用数组的方式输出:" << days[i] << " ";
//用指针的形式输出
cout << "用指针的方式输出:" << *(days + i);
cout << endl;
}
}
void print_2(int* day, int len) {
for (int i = 0; i < len; i++) {
//用数组的方式输出
cout << "用数组的方式输出:" << day[i] << " ";
//用指针的形式输出
cout << "用指针的方式输出:" << *(day + i);
cout << endl;
}
}
int main(void) {
int days[] = { 31,28,31,30,31,30,31,31,30,31,30,31 };
int* day = NULL;
int len = sizeof(days) / sizeof(int);
day = days;
//for (int i = 0; i < len; i++){
// //用数组的方式输出
// cout << "用数组的方式输出:" << days[i] <<" ";
// //用指针的形式输出
// cout << "用指针的方式输出:" << *(day + i);
// cout << endl;
//}
//当传入参数是数组时
cout << "当传入参数是数组时:" << endl;
print_1(days, len);
cout << "当传入参数是指针时:" << endl;
print_2(day, len);
return 0;
}存储指针的数组(指针数组:保存地址值)
定义： 类型 *指针数组名[元素个数] ；如:int *p[2]
定义一个有n个元素个数指针数组，每个元素都是一个指针变量
指针数组是先有地址值,然后再通过地址值,指针数组本质可以理解为不是一个指针而是一个只保存地址的数组,在操作指针数组时,这个指针数组是先保存有这个对象的地址(并不是指向这个对象),然后可以通过地址访问这个对象的值
#include <iostream>
using namespace std;
int main(void) {
int days[] = { 31,28,31,30,31,30,31,31,30,31,30,31 };
int len = sizeof(days) / sizeof(int);
int* p[1];//代表这个指针数组内,有一个指针变量
p[0] = days;
for (int i = 0; i < len; i++){
if (*p[0] > days[i]) {
p[0] = &days[i];
}
}
cout << *p[0] << endl;
return 0;
}指向数组的指针(数组指针)
1. 指向数组的指针
int (*p)[3]; //定义一个指向三个成员的数组的指针,数组指针的个数,和数组的列数是对应的
访问元素的两种方式：
数组法： (*p)[j]
指针法： *((*p)+j)
#include <iostream>
using namespace std;
int main(void) {
int days[4][3] = {31,28,31,30,31,30,31,31,30,31,30,31};
//几维的数据就将元素设为几个元素的指针
int (*p)[3];//定义一个指针数组,指向4个元素的的数组的指针
int* little = NULL;
//使用数组型的指针型数组访问
p = &days[0];
for (int i = 0; i < 4; i++){
for (int j = 0; j < 3; j++){
cout << (*p)[j] << " ";
}
p++;
}
cout << endl;
//使用指针型的指针数组访问
p = &days[0];
little = &(*p)[0];
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 3; j++) {
if (*little > *((*p) + j)) {
little = (*p) + j;
}
}
p++;
}
cout << *little << endl;
return 0;
}传参的形式(指针)
数组传参时会退化为指针
1）退化的意义：C 语言只会以值拷贝的方式传递参数，参数传递时，如果拷贝整个数组，效率会大大降低，并且参数将位于栈上，太大的数组拷贝将会导致栈溢出。
2）因此，C 语言将数组的传参进行了退化。将整个数组拷贝一份传入函数时，将数组名看做常量指针，传数组首元素的地址。(这样参数在进行赋值时,就会和这个数组共用同一个内存空间)
#include <iostream>
using namespace std;
//方法1
void method_1(int days[12]) {
for (int i = 0; i < 12; i++){
cout << days[i] << " ";
}
}
//方法2
void method_2(int days[], int len) {
for (int i = 0; i < len; i++) {
cout << days[i] << " ";
}
}
//方法3
void method_3(int* array, int len) {
for (int i = 0; i < len; i++) {
cout << *(array+i) << " ";
}
}
//方法4
void method_4(int* arr[]) {
for (int i = 0; i < 12; i++) {
cout << *arr[i] << " ";
}
}
//方法5
void method_5(int* arr[], int len) {
for (int i = 0; i < len; i++) {
cout << *arr[i] << " ";
}
}
//方法6
void method_6(int** arr, int len) {
for (int i = 0; i < len; i++) {
cout << *arr[i] << " ";
}
}
//方法7
void method_7(int(*k)[12]) {
for (int i = 0; i < 12; i++) {
cout << *(*k+i) << " ";
}
}
int main(void) {
//数组作为参数传递,输出数组的6种方式
int days[12] = {31,28,31,30,31,30,31,31,30,31,30,31};
int len = sizeof(days) / sizeof(int);
//方法一;
cout << "方法一:将数组作为形参参接收数组:" << endl;
method_1(days);
cout << endl;
cout << "方法二:将数组作为形参参接收数组,并指定数组的元素个数:" << endl;
method_2(days, len);
cout << endl;
cout << "方法三:使用指针作为形参接受数组,并指定数组的元素个数:" << endl;
method_3(days, len);
cout << endl;
cout << "方法四:使用指针数组作为形参:" << endl;
//先为指针数组内的元素赋值
int* day[12] = {0};//初始化,指针数组时先作为一个数组
for (int i = 0; i < len; i++){
day[i] = &days[i];
}
method_4(day);
cout << endl;
cout << "方法五:使用指针数组作为形参,并指定数组的元素个数:" << endl;
method_5(day, len);
cout << endl;
cout << "方法六:使用二级指针作为形参,并指定数组的元素个数:" << endl;
method_6(day, len);
cout << endl;
int(*k)[12];
k = &days;
cout << "方法七:使用数组指针作为形参接受数组:" << endl;
method_7(k);
return 0;
}void类型的指针
void => 空类型
void* => 空类型指针，只存储地址的值，丢失类型，无法访问，要访问其值，我们必须对这个指 针做出正确的类型转换(其他类型赋值给void指针,会自动转,void的指针赋值给其他类型则需要强制转换)，然后再间接引用指针。
void*类型的指针是无法进行算数运算的,同样无法访问(E0852 表达式必须是指向完整对象类型的指针)
#include <iostream>
using namespace std;
int main(void) {
int a = 10;
int* p = &a;
void* p1 = &a;
void* p2 = p; //其他类型的指针赋值给void类型的指针自动转换
p++;//有具体类型的指针可以算术运算
//p1++;//错误
int* p3 = (int*)p1;//void类型的指针赋值给其他类型的指针需要进行强制转换
//cout << *p1 << endl;//E0852:表达式必须是指向完整对象类型的指针
cout << p1 << endl;//可以输出他的地址值
cout << p2 << endl;
cout << *p3 << endl;
return 0;
}函数指针
函数指针简单理解就是把整个函数当做一个指针
#include <iostream>
using namespace std;
int add(int a, int b) {
return a + b;
}
int substr(int a, int b) {
return a - b;
}
//定义一个int型指针函数
//根据函数指针的类型为int
int(*getMath(bool type))(int a, int b){
if (getMath) {
return add;
}
else {
return substr;
}
}
int main(void) {
cout << getMath << endl;//函数名也是地址
cout << &getMath << endl;//取地址也是取函数的地址,是一样的
return 0;
}定义:
把函数声明移过来，把函数名改成 (* 函数指针名)
例如:
定义一个函数为:int man(const void *a,const void *b){}
函数的指针定义为:int (*p)(const void *a ,const void *b);
最后将函数的地址赋值给指针:p = &man;
调用:
两种方式:(*指针名)(参数地址) 或者 指针名(参数地址)
例如上述:(*p)(&a,&b); 或者 p(&a,&b);
#include <iostream>
using namespace std;
int compare( void* a, void* b) {
int* x = (int*)a;
int* y = (int*)b;
return *x - *y;
}
int main(void) {
int arr[] = { 2, 10, 30, 1, 11, 8, 7,25 };
int len = sizeof(arr) / sizeof(int);
int (*p)( void* a, void* b);
p = &compare;//p= compare
cout << arr[0] << " " << arr[1] << endl;
cout << p(&arr[0], &arr[1]) << endl;
return 0;
}应用:
使用VS自带的快速排序函数,来调用自定函数进行排序
#include <iostream>
using namespace std;
int compare(const void* a,const void* b) {
int *x = (int*)a;
int *y = (int*)b;
return *x - *y;//小于0,升序排序,
}
int main(void) {
int arr[] = { 2, 10, 30, 1, 11, 8, 7,25 };
int len = sizeof(arr) / sizeof(int);
cout << "排序前:" << endl;
for (int i = 0; i < len; i++){
cout << arr[i] << " ";
}
int (*p)(const void* a,const void* b);
p = &compare;
//这里qsort函数的第四个参数需要的函数参数类型为const类型的指针
qsort(arr, len, sizeof(int), p);
cout << endl;//这个作用是换行
cout <<"排序后:" << endl;
for (int i = 0; i < len; i++) {
cout << arr[i] << " ";
}
return 0;
}函数返回值使用指针(指针函数)
可以返回函数内部：动态分配内存地址 局部静态变量地址 以及全局静态变量和外部变量 地址
动态分配内存空间
#include <iostream>
#include <stdlib.h>
using namespace std;
//返回动态内存分配地址
int* add1(int x, int y)
{
int* sum = NULL;
sum = new int;
*sum = x + y;
return sum;
}
int main()
{
int a = 3, b = 5;
int* sum = NULL;
//接收外部函数动态内存分配的地址 ok
sum = add1(a, b);
cout<<*sum<<endl;
delete sum;
system("pause");
return 0;
}不能使用外部函数的普通局部变量的地址
(普通局部变量的值在函数调用结束后值会释放)
(这样是错误的 vs版本升级后,这种写法会触发断点,但是以前的不会),但是依然会运行出结果,这种结果会被栈空间覆盖掉(如果后面有其他函数用到这片空间)那么这个函数所运行的结果也会被后来的函数值覆盖掉,运行出来的值并不正确
#include <iostream>
#include <stdlib.h>
using namespace std;
int* add(int x, int y) {
int sum = x + y;
return ∑
}
//程序动态动态分配一块内存空间,这片空间会覆盖在上面函数在调用结束后,释放的空间之上
int* add1(int x, int y)
{
int* sum = NULL;
sum = new int;
*sum = x + y;
return sum;
}
int main()
{
int a = 3, b = 5;
int* sum = NULL;
//不能使用外部函数局部变量的地址(这样是错误的)
sum = add(a, b);
//如果再输出这个外部函数局部变量的值之前,调用一片由程序员动态分配内存的指针函数,那么这片申
//请的内存空间会覆盖掉上面函数的之前使用的空间,
add1(a,b);
cout<<*sum<<endl;//这里输出的值就会受到上面这个函数的影响从而返回错误的值
delete sum;
system("pause");
return 0;
}通过指针函数返回静态局部变量的地址
:这种方法是可以的,不同于上面这种普通局部变量,静态变量的特点:(只会初始化一次,但是当函数调用结束后,运行出来的值并不会释放)
#include <iostream>
#include <stdlib.h>
using namespace std;
//通过指针函数返回静态局部变量的地址
int* add(int x, int y)
{
static int sum = 0;//静态变量的值不会因为函数调用结束而释放
cout << "函数内部的值:" << sum << endl;
sum = x + y;
return ∑
}
int main()
{
int a = 3, b = 5;
int* sum = NULL;
sum = add(a, b);
cout << "第一次调用静态后的函数值:" << *sum << endl;
*sum = 8888;
sum = add(a, b);
cout << "第二次调用静态后的函数值:" << *sum << endl;
return 0;
}补充:指针函数和函数指针不同:
函数指针是指向函数的指针变量，用于存储和调用函数。
指针函数是返回值为指针类型的函数，用于返回不同的指针值或函数指针。
函数指针作为一个指针,可以指向指针函数的
#include <iostream>
using namespace std;
int add(int a, int b) {
return a + b;
}
int substr(int a, int b) {
return a - b;
}
//定义一个int型指针函数
//根据函数指针的类型为int
int(*getMath(bool type))(int a, int b){
if (getMath) {
return add;
}
else {
return substr;
}
}
int main(void) {
int arr[] = { 2, 10, 30, 1, 11, 8, 7,25 };
int len = sizeof(arr) / sizeof(int);
int (*p)(int a, int b);//通过定义一个函数指针
p = getMath(true);//将这个函数指针,指向指针函数
cout << p(arr[1], arr[2])<< endl;
return 0;
}
117
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
