指针
const指针
观察如下三行代码:
const int* pa; //由于int const i; 和 const int i; 两种写法一致
int const* pa; //所以这两种指针也都是一样的,表示指向的内容只读。
//在函数的形参列表中如果出现了指向const类型的指针,则表示它是入参。
int* const pa; //而如果const出现在了标识符和指针定义标记*之间,则表示指针的指向不能变
volatile关键字
观察如下代码:
#include <stdio.h>
int main()
{
const int a = 10;
int* pa = (int*)&a;
*pa = 8;
printf("*pa = %d, a = %d\n", *pa, a);
return 0;
}
在这个代码中,&a的类型实际上是 const int*,但其被强转成了 int* ,故 *pa 就可以被修改了。此 时修改完毕后,打印结果就会变得奇怪了,在后缀.c的情况下,能看到两个都是8,而在后缀 .cpp 的 情况下,a的值就变成了10,而 *pa 仍然是8。
出现这样现象的原因是编译器的寄存器优化,在编译器运算的过程中,经常会将一些变量临时的放在寄 存器中,以加速这些常用变量的读写速度。其中, const 类型的变量就经常被优化,即上述中 其内存中的地址,而a被寄存器优化了,所以读取 *pa 表示 *pa 是去内存中读,而a的值是从寄存器中读出来 的。这样就产生了差异。
但很多全局性资源所有程序都可以访问,所以对于这些资源,不可控的寄存器优化就有可能导致访问出 的数据出问题,如在A程序处理时,B程序已经修改了这个全局资源的内容,而A程序将其寄存器优化 了,这样就会导致A程序中对应的资源访问出现错误。此时就需要 volatile 关键字来禁止寄存器优化 了:
#include <stdio.h>
int main()
{
volatile const int a = 10; //使用volatile禁止a的寄存器优化
int* pa = (int*)&a;
*pa = 8;
printf("*pa = %d, a = %d\n", *pa, a); //此时就会强制去内存中读取a
return 0;
}
通过这样的写法就可以避免出现同一地址上的变量打印值不同的问题了。
register 关键字可以建议编译器将变量定义在寄存器中,由于寄存器不是内存的一部分,所以 register 变量无法取地址。
动态二维数组
动态二维数组就是两个维度都是动态分配出的数组,其基本逻辑是先通过一个二级指针分配一个一级指 针的动态数组,再给这个数组中的所有一级指针逐个分配空间:
void formalloc(int*** pform, int n, int m)
{
int** form = (int**)malloc(n * sizeof(int*));
int i;
for (i = 0; i < n; i++)
{
form[i] = (int*)malloc(m * sizeof(int));
}
*pform = form;
}
上述代码就分配了一个n行m列的动态二维数组。
动态二维数组的释放:
void formfree(int** form, int n)
{
int i;
for (i = 0; i < n; i++) //先释放每行
{
free(form[i]);
}
free(form); //再释放整体
}
上面的分配代码没有考虑分配失败的场景,如果考虑了,代码会变成这样:
int formalloc(int*** pform, int n, int m)
{
int** form = (int**)malloc(n * sizeof(int*));
if (form == NULL)
{
return -1;
}
int i;
for (i = 0; i < n; i++)
{
form[i] = (int*)malloc(m * sizeof(int));
if (form[i] == NULL)
{
formfree(form, i); //分配失败时注意释放已经分配的空间
return -1;
}
}
*pform = form;
return 0;
}
※动态二维数组和普通的二维数组不同,普通的二维数组是一整片的连续空间,而动态二维数组是由 n+1 块离散空间组合而成的。
动态二维数组的访问方式和普通的二维数组相同,但整体上更加灵活。
复杂类型的辨认和编写
复杂类型的辨认
观察以下两个代码:
//代码1
(*(void (*)())0)();
//代码2
void (*signal(int , void(*)(int)))(int);
遇到这种问题,需要以标识符作为切入点解决问题。根据各个部分距离标识符的优先级次序来逐个解决问题。
在代码1中,没有标识符,但存在一个常量0,所以只能以0为切入点分析都有什么作用于它了,那么:
1、 (void ( * )())这个小括号内包含了一个函数指针类型,所以这其实是一个强转运算符,将0强转成 了一个没有参数也没有返回值的函数指针。
2、* 这个显然是解引用运算符,作用于函数指针时可忽略
3、()这个小括号在0的右边,所以显然是函数调用运算符,调用了前面以0为地址的函数。
所以这行代码是一个函数调用,它以无参、无返回值的方式调用了一个地址为0的函数。
在代码2中,标识符为 signal ,此时同样按照优先级次序来看,则
1、 signal(int , void(*)(int))这个部分显然是一个函数的参数列表,所以这行代码是一个函数声明。
2、既然是函数声明,那么剩下的就是返回值类型了,去掉标识符和参数列表,剩下的是 void( * ) (int) ,和参数2一致。所以,事实上,代码2如果用typedef 优化一下,会更好阅读:
typedef void (*FUNCI)(int);
FUNCI signal(int, FUNCI);
可以看出解决这类问题的关键是找到标识符,然后按照优先级次序逐个处理即可。
以如下代码为例:
int (*(*fun(int*(*p)(int *)))[5]) (int*);
这个代码中出现了两个疑似标识符,此时只需要随便拿一个开刀就行,如,选择p作为标识符
1、离p最近的是 * ,它是一个指针定义。
2、下一个是 (int* ) ,显然,p是一个函数指针,完整拿出来 int* (p)(int * ),可以看出p的参数列表和返回值类型都是 int 。
接下来发现没有作用于它的类型标记了,所以,说明我们刚刚分析的p是函数的一个参数。那么剩余的 fun 就是标识符了。那么如法炮制,继续对 fun 找作用对象:
1、小括号 (int* (*p)(int *)) ,所以 fun 是函数声明。所以去掉它和参数列表,剩余的就是返回值类型,为了方便阅读,加上一个pr,得到返回值类型为:
int (*(*pr)[5]) (int*);
可以看出,pr的类型就是返回值类型。那么继续如法炮制分析pr的类型:
1、* ,它是一个指针
2、[5],这个指针指向了一个5个元素的数组
3、* ,它是一个指针,指向了上述的结构
4、( int* ) 这是一个函数指针,参数列表是 int* ,返回值为int
故综上所述,它是一个函数指针数组指针,即一个指针指向了一个函数指针数组,这个数组的大小是5, 函数的参数列表是 int* ,返回值是 int 。
最终我们得到了原代码的含义:
fun 是一个函数声明,这个函数的参数是一个参数为 int 、返回值类型为 int 的函数指针。而它的返回值是一个指针,这个指针指向了一个5个元素的函数指针数组,其中这些函数的参数为int* ,返回值为int 。**
复杂类型的编写
接下来完成一个复杂类型的编写。
一般而言,编写过程都非常简单,只需要找到句子的宾语,然后不停的追问宾语即可。
如果定义牵涉函数声明或者函数指针定义,则需要对参数列表和返回值类型分别这样做,最后组装起来。
以刚刚得到的这段表述为例:
定义一个函数声明,这个函数的参数是一个参数为 int* 、返回值类型为 int* 的函数指针。而它的返回值是一个指针,这个指针指向了一个5个元素的函数指针数组,其中这些函数的参数为int* ,返回值为int 。
首先,这是一个函数声明,所以分开考虑参数和返回值。先看参数:
1、函数指针,可以直接完成: int*(p)(int) *
2、先将参数组装到函数声明里: fun(int * ( p)(int*)) (计做①式)
其次,继续分析返回值类型:
一个指针,这个指针指向了一个5个元素的函数指针数组,其中这些函数的参数为 int ,返回值为 int 。*
1、宾语是指针:*p
*2、什么样的指针?指向了一个5个元素的数组的指针 ( * p)[5]
*3、什么样的数组?函数指针的数组 ( * (*p)[5])
4、什么样的函数?参数为 int * ,返回值为int 的函数:int ( * ( * p)[5])(int)
此时,返回值类型编写完毕,将①式直接代换掉上面的临时标识符p:
int (*(*fun(int*(*p)(int*)))[5])(int*);
就完成了类型的还原。
392



被折叠的 条评论
为什么被折叠?



