1 const修饰指针
技巧:
看const在指着左侧,还是右侧:const放在 * 前是修饰指向的对象,放在*后则是修饰指针本身。
- (1)const在指针左侧,常量指针;const int *a;
常量的指针,a是一个指向整型常量的指针变量,指向地址可以修改,指向的值不可改; - (2)const指针右侧,指针常量; int * const a;
指针是常量,a是一个指向整型变量的指针常量,指向地址不可以修改,指向的值可改;
int main() {
int a = 10;
int b = 20;
//1. 常量指针
//指针指向的值不可以改,指针的指向可以改
const int * p1 = &a; //同 int const * p1 = &a;
*p1 = 100; //错误
p1 = &b; //正确
//2.指针常量,
//指针指向的值可以改,指针的指向不可以改
int* const p2 = &a;
*p2 = 100; //正确
p2 = &b; //错误
//3.const既修饰针织,又修饰常量
//指针指向的值不可以改,指针的指向不可以改
const int* const p3 = &a;
*p3 = 100; //错误
p3 = &b; //错误
return 0;
}
5.1 常量指针 const int * p=&a; 同 int const * p1 = &a;
int a=10;
const int * p=&a;
1.2 指针常量 int * const p=&a;
int a=10;
int * const p=&a;
1.3 cons既修饰指针,又修饰常量 const int * const p = &a;
int a= 10;
const int * const p = &a;
2 数组指针和指针数组
(*p)[n],数组指针,数组的指针:是一个指针,什么样的指针呢?指向数组的指针。
*p[n],指针数组,指针的数组:是一个数组,什么样的数组呢?装着指针的数组。
确一个优先级顺序:()>[]>* 所以
(*p)[n]:根据优先级,先看括号内,则p是一个指针,这个指针指向一个一维数组,数组长度为n,这是“数组的指针”,即数组指针;
*p[n]:根据优先级,先看[],则p是一个数组,再结合,这个数组的元素是指针类型,共n个元素,这是“指针的数组”,即指针数组。
根据上面两个分析,可以看出,p是什么,则词组的中心词就是什么,即数组“指针”和指针“数组”。
int *p1[5];
int (*p2)[5];
首先,对于语句“int * p1[5]”,因为“[]”的优先级要比 “ * ” 要高,所以 p1 先与“[]”结合,构成一个数组的定义,数组名为 p1,而“int*”修饰的是数组的内容,即数组的每个元素。也就是说,该数组包含 5 个指向 int 类型数据的指针, 所示,因此,它是一个指针数组。
其次,对于语句“int(*p2)[5]”,“()”的优先级比“[]”高,“ * ”号和 p2 构成一个指针的定义,指针变量名为 p2,而 int 修饰的是数组的内容,即数组的每个元素。也就是说,p2 是一个指针,它指向一个包含 5 个 int 类型数据的数组,如图 2 所示。很显然,它是一个数组指针,数组在这里并没有名字,是个匿名数组。
由此可见,对指针数组来说,首先它是一个数组,数组的元素都是指针,也就是说该数组存储的是指针,数组占多少个字节由数组本身决定;而对数组指针来说,首先它是一个指针,它指向一个数组,也就是说它是指向数组的指针,在 32 位系统下永远占 4 字节,至于它指向的数组占多少字节,这个不能够确定,要看具体情况。
2.1 指针数组 *p1[5]
数据类型 *数组名[常量表达式][常量表达式]...... ;
它是一个数组,数组的元素都是指针,数组占多少个字节由数组本身的大小决定,每个元素都是一个指针。
例如:char *arr[]={“Sunday”,“Monday”},存储了两个指针,第一个指针指向了字符串"Sunday",第二个指针指向了字符串"Monday",而sizeof(arr)=8,因为在32位平台,指针类型大小占4个字节。指针数组最重要的用途是对多个字符串进行处理操作,因为字符指针比二维数组更快更有效。
下面是个简单的例子
#include <stdio.h>
int main()
{
//定义三个整型数组
int a[5] = { 1,2,3,4,5 };
int b[5] = { 6,4,8,3,1 };
int c[5] = { 2,5,8,6,1 };
//定义一个存放指向整型变量的指针的数组arr
int* arr[] = { a,b,c };
//通过接引用打印出三个一维数组的元素
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 5; j++)
{
printf("%d ", *(arr[i]+j));
}
printf("\n");
}
return 0;
}
结果如下:
1 2 3 4 5
6 4 8 3 1
2 5 8 6 1
以上对arr解引用的方式有很多,它们都是等价的,我们来举个例子:
#include<stdio.h>
int main()
{
int i = 0;
int a[3][4] = { {1,2,3,4} ,{5,6,7,8} ,{9,10,11,12} };//定义一个二维数组
int* pa[3];//定义一个指针数组
for (i = 0; i < 3; i++)//给指针数组赋值
pa[i] = a[i];
printf("指针数组的内容为:\n");
for (i = 0; i < 3; i++)//打印出指针数组的内容
{
int j;
for (j = 0; j < 4; j++)
printf("%d ", *(*(pa + i) + j));
printf("\n");
}
//以下均为不同方式的解引用操作
printf("不同解引用操作的结果为:\n");
printf("%d,%d\n", a[1][1], *(pa[1] + 1));
printf("%d,%d\n", a[1][1], *(*(pa+1) + 1));
printf("%d,%d\n", a[1][1], (*(pa + 1))[1]);
printf("%d,%d\n", a[1][1], pa[1][1]);
return 0;
}
结果如下所示:
指针数组的内容为:
1 2 3 4
5 6 7 8
9 10 11 12
不同解引用操作的结果为:
6,6
6,6
6,6
6,6
从以上例子可看出解引用有多种方式,它们的等价形式如下:
*( pa[i] + j ) //等价于 *( a[i] + j )
*( *(p+i) + j ) //等价于 *( *(a+j) + j )
( *(p+i) )[ j ] //等价于( *(a+i) )[ j ]
p[ i ][ j ] //等价于 a[i][j]
补充(1):指针数组还可以和字符串数组相结合使用,请看下面的例子:
#include <stdio.h>
int main(){
char *str[3] = {"lirendada","C语言","C Language"};
printf("%s\n%s\n%s\n", str[0], str[1], str[2]);
return 0;
}
结果如下:
lirendada
c语言
C Language
需要注意的是,字符数组 str 中存放的是字符串的首地址,不是字符串本身,字符串本身位于其他的内存区域,和字符数组是分开的。
也只有当指针数组中每个元素的类型都是char *时,才能像上面那样给指针数组赋值,其他类型不行。
为了便于理解,可以将上面的字符串数组改成下面的形式,它们都是等价的。
#include <stdio.h>
int main(){
char *str0 = "lirendada";
char *str1 = "C语言";
char *str2 = "C Language";
char *str[3] = {str0, str1, str2};
printf("%s\n%s\n%s\n", str[0], str[1], str[2]);
return 0;
}
补充(2):二维数组与指针数组的区别
char *p1[]={"lirendada","C","C++"};
char p2[][8]={"liren","C","C++"};
*p1,*(p1+1),*(p1+2):所指向的字符串常量是不规则长度的,且sizeof(p1)=12。
p2[0],p2[1],p2[2]所指向的字符串都是一定长度的,且sizeof(p2)=24。
2.2 数组指针 (*p2)[5]
注:因为数组指针对于一维数组的使用比较尴尬,对于一维数组,建议使用指针数组比较方便,这里只涉及到关于二维数组与数组指针的知识!!!
首先引入二维数组的定义:二维数组在概念上是二维的,有行有列,但在内存中所有的元素都是连续排列的,以下面的二维数组为例:
int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
从概念上理解,a的分布就像一个矩阵:
1 2 3 4
5 6 7 8
9 10 11 12
从内存上理解,整个数组占用一块连续的内存:
C语言中的二维数组是按行排列的,也就是先存放 a[0] 行,再存放 a[1] 行,最后存放 a[2] 行;每行中的 4 个元素也是依次存放。数组 a 为 int 类型,每个元素占用 4 个字节,整个数组共占用 4×(3×4) = 48 个字节。
C语言允许把一个二维数组分解成多个一维数组来处理。对于数组 a,它可以分解成三个一维数组,即 a[0]、a[1]、a[2]。每一个一维数组又包含了 4 个元素,例如 arr[0] 包含 a[0][0]、a[0][1]、a[0][2]、a[0][3]。
假设数组a中第0个元素的地址为1000,那么每个一维数组的首地址如下图所示:
int (*p)[4] = a ;
括号中的*表明 p 是一个指针,它指向一个数组,数组的类型为int [4],这正是 a 所包含的每个一维数组的类型。
[]的优先级高于 * ,()是必须要加的,如果赤裸裸地写作int* p[4],那么应该理解为int *(p[4]),p 就成了一个指针数组,而不是二维数组指针。
对指针进行加法(减法)运算时,它前进(后退)的步长与它指向的数据类型有关,p 指向的数据类型是int [4],那么p+1就前进 4×4 = 16 个字节,p-1就后退 16 个字节,这正好是数组 a 所包含的每个一维数组的长度。也就是说,p+1会使得指针指向二维数组的下一行,p-1会使得指针指向数组的上一行。数组名 a 在表达式中也会被转换为和 p 等价的指针!
#include <stdio.h>
int main(){
int a[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} };
int (*p)[4] = a;
printf("%d\n", sizeof(*(p+1)));
return 0;
}
运行结果为下面所示:
16
- *(p+1)+1表示第 1 行第 1 个元素的地址。如何理解呢?
*(p+1)单独使用时表示的是第 1 行数据,放在表达式中会被转换为第 1 行数据的首地址,也就是第 1 行第 0 个元素的地址,因为使用整行数据没有实际的含义,编译器遇到这种情况都会转换为指向该行第 0 个元素的指针;就像一维数组的名字,在定义时或者和 sizeof、& 一起使用时才表示整个数组,出现在表达式中就会被转换为指向数组第 0 个元素的指针
- ((p+1)+1)表示第 1 行第 1 个元素的值。很明显,增加一个 * 表示取地址上的数据。
根据上面的结论,可以很容易推出以下的等价关系:
a+i == p+i
a[i] == p[i] == *(a+i) == *(p+i)
a[i][j] == p[i][j] == *(a[i]+j) == *(p[i]+j) == *(*(a+i)+j) == *(*(p+i)+j)
【实例】使用指针遍历二维数组。
#include <stdio.h>
int main(){
int a[3][4]={0,1,2,3,4,5,6,7,8,9,10,11};
int(*p)[4];
int i,j;
p=a;
for(i=0; i<3; i++){
for(j=0; j<4; j++) printf("%2d ",*(*(p+i)+j));
printf("\n");
}
return 0;
}
运行结果:
0 1 2 3
4 5 6 7
8 9 10 11
指针数组和二维数组指针的区别
指针数组和二维数组指针在定义时非常相似,只是括号的位置不同:
int *(p1[5]); //指针数组,可以去掉括号直接写作 int *p1[5];
int (*p2)[5];//二维数组指针,不能去掉括号
指针数组和二维数组指针有着本质上的区别:指针数组是一个数组,只是每个元素保存的都是指针,以上面的 p1 为例,在32位环境下它占用 4×5 = 20 个字节的内存。二维数组指针是一个指针,它指向一个二维数组,以上面的 p2 为例,它占用 4 个字节的内存。
3 函数指针和指针函数
函数指针,本质上是一个指针,它指向的是一个函数的地址。
void(*p2)(int a,int b);
指针函数,本质上是一个函数,他的返回值是一个指针.(要用相同类型的指针接收返回值)
int *add(int a,int b);
3.1 函数指针 void(*p2)(int a,int b)
int Max(int a, int b) {
return a > b ? a : b;
}
int main() {
int (*p2)(int a, int b);//声明一个函数指针
int a = 10, b = 20;
p2 = Max;//初始化函数指针,把Max赋给指针变量p,使p指向Max函数
int c = p2 (a, b); //通过函数指针调用Max函数
//int c = (*p2) (a, b); //同 int c = p2 (a, b);
printf("c = %d",c);
return 0;
}
我们都知道数组名就代表这个数组的首地址,函数名也一样,函数名就代表这个函数的地址,所以用p2这个指针指向Max这个函数。
如何调用函数指针:
(1)直接通过指针名字+需要传递的参数,如: p2(a,b);
(2)取内容+需要传递的参数,如:(*p2)(a,b);
3.2 指针函数 int *add(int a,int b) 必须有返回值,返回指针
int* add(int a, int b) {
int c = a + b;
return &c;
}
int main() {
int a = 10, b = 20;
int* p = add(a, b);//因为add的返回值是一个指针,所以要用相同类型的指针接收返回值
printf("p = %d\n", *p);
return 0;
}
char *str = func(s1, s2);//函数返回值是一个指针,即接收端也是一个指针;
char* s1 = "C Language";
#include <stdio.h>
#include <string.h>
// 返回两个字符串中较长的一个
char* func(char* str1, char* str2)
{
return strlen(str1) >= strlen(str2) ? str1 : str2;
//由于字符串名,就是地址,所以不需要地址符
}
int main()
{
char* s1 = "C Language";
char* s2 = "C is very great!";
char* longstr = func(s1, s2);
printf("Long string: %s\n", longstr);
return 0;
}
如果你尝试初始化非常量会导致 C2440 char* (或wchar_t*) 通过使用中的字符串文字C++代码,当编译器一致性选项/zc: strictstrings设置。 在 C 中,字符串文字的类型是数组char,但在C++,它是数组const char。 此示例生成 C2440:
解决:将char型指针,改为常量char 型指针
char* s1 = "test"; // C2440
const char* s2 = "tests"; // OK
于是都改成,const char*,结果fun返回值有问题,,,,,于是头文件改成c++的还是有问题。。。。
。
。
。
。
。
。
网上C语言字符串就是这么写的为啥没问题呢?
难道,VS版本问题?。。
头文件<stdio.h>,也没毛病呀!
终于发现了问题,文件名后缀.cpp,,是C++ 后缀名,于是把文件名后缀改成.c就好了。
#include <stdio.h>
// 返回两个字符串中较长的一个
char* func(char* str1, char* str2)
{
return strlen(str1) >= strlen(str2) ? str1 : str2;
}
int main()
{
char* s1 = "C Language";
char* s2 = "C is very great!";
char* longstr = func(s1, s2);
printf("Long string: %s\n", longstr);
return 0;
}