经典用法
定制指针变量*p后， *p和p的区别
*p表示此指针指向的内存地址中存放的内容。
p是一个指针变量的名字，表示此指针变量指向的内存地址。
1. 权限的问题 ()
const int * // 即p可变，*p不可变。const右边接近于int, 只读，不可以写
int* const p //p为const，不能对p赋值，所以p不可变 但是*p可变
2. 函数参数为指针
3. 利用指针打印一个字符串
4. 一个函数通过指针做到返回两个值
5. 同一个编译器下面，一个指针无论指向什么类型的变量，指针占用的空间都是一样的
(所以如果有的变量占用内存空间多的话，利用指针来赋值内存空间效率更高，因为指针占用的内存空间是固定的)
备注：但是类型还是要一致，同类型指针指向同类型变量，否则会报错
6. 指针可以指向整个数组，也可以指向数组当中的某个元素。利用指针遍历数组元素
#include<iostream>
#include<algorithm>
#include<string.h>
#include<string>
#include<numeric>
#include<iomanip>
#include<math.h>
#include<bitset>
#include<vector>
#include<stack>
#include<map>
#include<stdio.h>
#include<set>
using namespace std;
void function(int* b)//参数是一个指针变量，
{
printf("%d\n", *b);
}
struct student
{
char* name;
int age;
}stu;
void function(student* b)
{
printf("%s\n", b->name);
printf("%d\n", b->age);
}
int sumandminus(int x, int y, int* p)
{
*p = x - y;
return x + y;
}
int main()
{
int a = 10, b = 20;
int* p = &a;
//========================================
p = &b; // 改变指向的权限
*p = 30; // 修改内存的权限
//========================================
const int* cp = &a; // 限制修改权限
//*cp = 100; // error：表达式必须是可修改的左值 修改
cp = &b; // ok.指向
//===========================================================
int* const pa = &a; // 限制指向权限
*pa = 100; // ok.修改
//pa = &b; // error：表达式必须是可修改的左值 指向
//把指针当作一个函数参数
int d = 10;
function(&d);//送进去的是一个变量的地址
/*
输出结果是：10
*/
printf("=============================\n");
//利用指针打印一个字符串
char name[] = "Australia";
printf("%s\n", &name);//打印的是整个数组 "Australia"
printf("=============================\n");
//结构体作为函数参数
char ch[] = "Australia";
stu = { ch, 38 };
function(&stu);
printf("=============================\n");
//一个函数通过指针做到返回两个值
int a1 = 10, b1 = 20;
int ans, minus;
ans = sumandminus(a1, b1, &minus);
printf("%d\n%d\n", ans, minus);
printf("=============================\n");
//利用指针更改数组元素
int a2[2];
int* p2 = a2;//这个就相当于 int* p = a[0]
*p2 = 20;
printf("%d\n", *p2);
printf("%d\n", a2[0]);
printf("=============================\n");
//利用指针遍历整个数组
int num[3] = { 5,7,9 };
int* p3 = num;
for (int i = 0; i < 3; i++)
{
printf("num[%d]=%d\n", i, *(p3 + i));//这个不是p1+2*i, 因为p1已经定义为int类型了, p1指向number[0]
}
printf("\n");
for (int i = 0; i < 3; i++)
{
printf("num[%d]=%d\n", i, *(p3++));//这个和上面的记过可能是一样，但是意思不一样，因为p1指向的地址不一样了，p1指向number[2]
}
printf("\n");
for (int i = 0; i < 3; i++)
{
printf("num[%d]=%d\n", i, *(num + i));//这种方法也是可以的，但是这里不可以写成*（num++)
}
printf("\n");
//普通写法
for (int i = 0; i < 3; i++)
{
printf("num[%d]=%d\n", i, num[i]);
}
return 0;
}
7. 指针数组
#include<iostream>
#include<string>
#include<string.h>
#include<iomanip>
#include<math.h>
#include<vector>
#include<stack>
#include<algorithm>
#include<bitset>
#include<numeric>
#include<map>
#include<stdio.h>
using namespace std;
//指针数组
int main()
{
int a[5] = { 1,2,3,4,5 };
int(*p)[5] = &a;//指针数组一定和上面的数组长度一致
//(int*)(p + 1)指向的是数组a[5]后面的内存，*((int*)(p + 1) -2) 就是往前推2个地址，就是4的位置
printf("%d", *((int*)(p + 1) - 2));//得到4
return 0;
}
8. 数组，指针，函数之间的关系
#include<iostream>
#include<algorithm>
#include<string.h>
#include<string>
#include<numeric>
#include<iomanip>
#include<math.h>
#include<bitset>
#include<vector>
#include<stack>
#include<map>
#include<stdio.h>
#include<set>
using namespace std;
//如果函数的参数是一个数组，只要求传送一个地址给它就行，不管是数组还是指针变量
//要求指针变量的类型要和数组一致
void change(char ch[])
{
ch[0] = 1;
ch[1] = 5;
}
//如果函数的参数是一个指针变量，只要求传送一个地址给它就行，不管是数组还是指针变量
//要求指针变量的类型要和数组一致
void change2(char *ch)
{
*ch = 10;
*(ch + 1) = 20;
*(ch + 2) = 30;
}
//即使形参是指针，
//参数里面也可以用数组来表示
void change3(char* ch)
{
ch[0] = 15;
ch[1] = 18;
ch[2] = 19;
}
int main()
{
char a[3];
//题目一
//方法一，直接用数组作为参数
change(a);
printf("a[0]=%d\na[1]=%d\n", a[0], a[1]);
//方法二，使用指针作为参数
char* p = a;
change(p);//p存储的就是一个地址
printf("a[0]=%d\n", *p);
printf("a[1]=%d\n", *(p + 1));
//
//
//=============================
printf("========================\n");
//=============================
//
//
//题目二
char b[10];
//方法一，直接用数组作为参数
change2(b);//数组和指针通用
printf("b[0]=%d\nb[1]=%d\n", b[0], b[1]);
//方法二，使用指针作为参数
char* q = b;
change2(q);//数组和指针通用
printf("b[0]=%d\n", *q);
printf("b[1]=%d\n", *(q + 1));
//=============================
printf("========================\n");
//=============================
//
//
//题目三
//方法一，直接用数组作为参数
char c[10];
change3(c);//数组和指针通用
printf("c[0]=%d\nc[1]=%d\n", c[0], c[1]);
//方法二，使用指针作为参数
char* t = c;
change3(t);//数组和指针通用
printf("c[0]=%d\n", *t);
printf("c[1]=%d\n", *(t + 1));
return 0;
}9. 指针和字符串的关系
#include<iostream>
#include<algorithm>
#include<string.h>
#include<string>
#include<numeric>
#include<iomanip>
#include<math.h>
#include<bitset>
#include<vector>
#include<stack>
#include<map>
#include<stdio.h>
#include<set>
using namespace std;
//指针和字符串之间的关系
void printchar()
{
char s2[] = "Australia";//定义的是一个字符串变量
char* p3 = s2;
while (*p3 != '\0')
{
printf("%c", *p3);
p3++;
}
}
void printchar2()
{
/*不可以写成
char a[10]
a = "Australia"
因为a是一个常量，对应的是数组的地址而不是字符
*/
char str1[] = "hello world";
char* p4 = str1;//p4指向"hello world"的第一个字符，而不是整个字符串
while (*p4 != '\0')
{
printf("%c", *p4);
p4++;
}
}
int main()
{
char s[] = "mj"; //其实是s[0] ='m'; s[1] ='j'; s[2] ='\0';
char s1[] = "itcast";//s1[6] = '\0' 这个不要忘记了
char* p = s;
char* p1 = s1;
printf("s=%s\n", s);
printf("s1=%s\n", s1);
printf("================\n");
//也可以利用循环遍历整个字符串数组
printchar();
printf("\n");
printf("================\n");
//也可以利用循环遍历整个字符串数组
printchar2();
//定义的是一个字符串常量，这种不可以修改
const char* p5 = "jfdasjlfdaj";
return 0;
}10. 返回指针的函数
函数占用一定的储存空间，所以它一定也有一个地址 ,函数名就是函数的地址
返回了函数的地址，通过“ *函数名”就可以拿到函数的数值了
#include<iostream>
#include<algorithm>
#include<string.h>
#include<string>
#include<numeric>
#include<iomanip>
#include<math.h>
#include<bitset>
#include<vector>
#include<stack>
#include<map>
#include<stdio.h>
#include<set>
using namespace std;
int* change() //返回指针的一个函数
{
int a = 10;
return &a;
}
const char* change1() //返回指针的一个函数
{
return "Australia";
}
int main()
{
printf("%d\n", *change());//得到10
printf("%s\n", change1());//得到"Australia"
return 0;
}11. 函数指针：指针指向一个函数的用途：可以把一个函数当作参数来使用
#include<iostream>
#include<algorithm>
#include<string.h>
#include<string>
#include<numeric>
#include<iomanip>
#include<math.h>
#include<bitset>
#include<vector>
#include<stack>
#include<map>
#include<stdio.h>
#include<set>
using namespace std;
int sum_1(int a, int b)
{
int c = a + b;
return c;
}
int minus_1(int a, int b)
{
int c = a - b;
return c;
}
int mul_1(int a, int b)
{
int c = a * b;
return c;
}
int count(int a, int b, int(*p)(int, int))//利用指针把一个函数当作参数来使用
{
return p(a, b);
}
//指针指向一个函数的用途：可以把一个函数当作参数来使用
int main()
{
//代表定义了一个指向函数的指针
//被指针指向的函数：返回值为int类型
int result_1, result_2, result_3;
result_1 = count(5, 6, sum_1);
printf("result_1: %d\n", result_1);
result_2 = count(5, 6, minus_1);
printf("result_2: %d\n", result_2);
return 0;
}12. 结构体
#include<iostream>
#include<algorithm>
#include<string.h>
#include<string>
#include<numeric>
#include<iomanip>
#include<math.h>
#include<bitset>
#include<vector>
#include<stack>
#include<map>
#include<stdio.h>
#include<set>
using namespace std;
//定义了一个结构体类型。但是这里并没有给结构体分配内存空间
//结构体的大小就是成员占用的大小之和(然后空间再做一个大小对齐)，并且地址是连续的
struct student
{
int age;
char* name;
float height;
int score;
};
char str[] = "steven";
//在这里才给结构体变量分配内存空间
student stu = {20, str, 1.82, 99};
int main()
{
//验证四个成员的地址都是连续的
printf("%d\n", &stu.age);
printf("%d\n", &stu.name);
printf("%d\n", &stu.height);
printf("%d\n", &stu.score);
printf("%d\n", sizeof(stu));//总共16个byte
printf("===================\n");
printf("%d\n", stu.age);
printf("%s\n", stu.name);
printf("%f\n", stu.height);
printf("%d\n", stu.score);
return 0;
}注意：
1）结构体本身不可以做递归定义
2）结构体里面可以包含别的结构体，赋值方法需要注意
3）结构体数组：其实玩法和普通数组没有任何区别。
#include<iostream>
#include<algorithm>
#include<string.h>
#include<string>
#include<numeric>
#include<iomanip>
#include<math.h>
#include<bitset>
#include<vector>
#include<stack>
#include<map>
#include<stdio.h>
#include<set>
using namespace std;
//定义了一个结构体类型。但是这里并没有给结构体分配内存空间
//结构体的大小就是成员占用的大小之和，并且地址是连续的
struct student
{
int age;
char* name;
float height;
int score;
personalinformation info;
};
struct personalinformation
{
char* hometown;
char* hobby;
int grade;
};
char str_1[] = "steven";
char str_2[] = "China";
char str_3[] = "diving";
//在这里才给结构体变量分配内存空间
//结构体初始化
student stu = { 20, str_1, 1.82, 99, {str_2, str_3, 3} };
int main()
{
return 0;
}4）指向结构体的指针
#include<iostream>
#include<algorithm>
#include<string.h>
#include<string>
#include<numeric>
#include<iomanip>
#include<math.h>
#include<bitset>
#include<vector>
#include<stack>
#include<map>
#include<stdio.h>
#include<set>
using namespace std;
//定义了一个结构体类型。但是这里并没有给结构体分配内存空间
//结构体的大小就是成员占用的大小之和，并且地址是连续的
struct personalinformation
{
char* hometown;
char* hobby;
int grade;
};
struct student
{
int age;
char* name;
float height;
int score;
personalinformation info;
};
char str_1[] = "steven";
char str_2[] = "China";
char str_3[] = "diving";
//在这里才给结构体变量分配内存空间
//结构体初始化
student stu = { 20, str_1, 1.82, 99, { str_2, str_3, 3 } };
int main()
{
student* p = &stu;//定义一个结构体，并让指针指向结构体
//三种方式来访问结构体成员
printf("age=%d\n", stu.age);
printf("age=%d\n", (*p).age);
printf("age=%d\n", p->age);
return 0;
}13 一维数组和指针
1) 一维数组不是指针
#include<iostream>
#include<algorithm>
#include<string.h>
#include<string>
#include<numeric>
#include<iomanip>
#include<math.h>
#include<bitset>
#include<vector>
#include<stack>
#include<map>
#include<stdio.h>
#include<set>
using namespace std;
int arr[] = { 1,2,3,4,5,6,7 };
//两种写法完全一样
void printArray_1(int* arr, int len) // int arr[] 等价于 int * arr
{
for (int i = 0; i < len; i++)
{
//printf("%d", *(arr + i));
printf("%d", arr[i]);
}
}
void printArray_2(int* arr, int len) // int arr[] 等价于 int * arr
{
for (int i = 0; i < len; i++)
{
printf("%d", *(arr + i));
//printf("%d", arr[i]);
}
}
int main(){
printArray_1(arr, 6);
printf("\n");
printArray_2(arr, 6);
return 0;
}2) 除了两种情况下，一维数组名都是指向数组中首元素的地址
a. 对数组名，进行sizeof运算
b.对数组名，取地址，此时是取整个数组的地址
printf("%d\n", sizeof(arr));
printf("%d\n", &arr);//指向arr[0]的地址
printf("%d\n", &arr + 1);//跳的是整个数组的长度 arr[6]后面的下一个地址3) 数组名是指针常量，指针指向不可以修改，指针指向的数值可以修改（就是arr[0]的数值) int * const arr;
//arr[0] = 1000; 通过
//arr = NULL; 报错
//指针下标可以是负数，就是一种偏移，但是不建议这么写数组指针的定义
//方法一
typedef int(ARRAY_TYPE)[7];
ARRAY_TYPE* arrP = &arr;
//方法二
typedef int(*ARRAY_TYPE)[7];
ARRAY_TYPE p = &arr;
//方法三(最常用）
int(*p) = &arr;
644
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
