C/C++ 复杂声明

已于 2022-06-02 21:27:11 修改
阅读量241 收藏 7
点赞数 1
文章标签： c语言 c++ 排序算法
于 2022-05-31 17:06:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kevenbalabala/article/details/125069241
版权

复杂声明

往右优先。再往左。遇到最后一个右边的符号带上返回值。

优先级 () > [] > *

注：函数的指针==函数指针 存放数组的数组 == 二维数组

标有ILLEGAL的声明 为强行翻译。

如果有错误，希望大家可以多多指正。不理解评论区可以留言。

下面两部分是一样的。

练习

int i;                 //an int
//i是int类型

int *p;                //an int pointer (ptr to an int)
//p是一个int型指针

int a[];               //an array of ints
//a是一个存放int的数组

int f();               //a function returning an int
//f是一个返回值是int的函数

int **pp;              //a pointer to an int pointer (ptr to a ptr to an int)
//*pp是一个指针 int **pp 是指向int指针的指针

int (*pa)[];           //a pointer to an array of ints
(*pa) pa是一个指针  
(*pa)[]  pa指向数组   
int (*pa)[] pa是一个指向int数组的指针

int (*pf)();           //a pointer to a function returning an int
(*pf)() pf是一个指向函数的指针  
int (*pf)() pf是一个指向返回值是int函数的指针  -- 函数指针

int *ap[];             //an array of int pointers (array of ptrs to ints)
ap[] ap是一个数组  
int *ap[]  ap是一个存放int指针的数组

int aa[][];            //an array of arrays of ints
aa[] aa是一个数组  
aa[][] aa是一个每个位置都是数组的数组  
int aa[][] aa是一个存放int的二维数组

int af[]();            //an array of functions returning an int (ILLEGAL)
af[] af是一个数组  
af[]() 是一个存放函数的数组  
int af[]() af是一个存放返回值是int的函数的数组

int *fp();             //a function returning an int pointer
fp() fp是一个函数 
int *fp() fp是一个返回值是int指针的函数

int fa()[];            //a function returning an array of ints (ILLEGAL)
fa()是一个函数 fa()[]fa是一个函数数组 
int fa()[] fa是一个返回值是int数组的函数

int ff()();            //a function returning a function returning an int
ff() ff是一个函数 
ff()() ff是一个返回函数的函数 
int ff()() ff是一个返回值是int的函数的函数
                       //      (ILLEGAL)
int ***ppp;            //a pointer to a pointer to an int pointer
*ppp ppp是一个指针  
**ppp ppp是一个指向指针的指针  
int ***ppp ppp是一个指向int指针的指针的指针

int (**ppa)[];         //a pointer to a pointer to an array of ints
**ppa 是一个指向指针的指针 
(**ppa)[] ppa是一个指向数组的指针的指针  
int (**ppa)[] ppa是一个指向存放int数组的指针的指针

int (**ppf)();         //a pointer to a pointer to a function returning an int
**ppf ppf是一个指向指针的指针 
(**ppf)() ppf是一个指向函数的指针的指针  
int (**ppf)() ppf是一个指向返回值是int的函数的指针的指针

int *(*pap)[];         //a pointer to an array of int pointers
*pap pap是一个指针 
(*pap)[] pap是一个指向数组的指针 
int *(*pap)[] pap是一个指向存放int指针的数组指针

int (*paa)[][];        //a pointer to an array of arrays of ints
paa是一个指向存放int的数组的数组的指针

int (*paf)[]();        //a pointer to a an array of functions returning an int
(*paf)[] paf是一个指向数组的指针 
(*paf)[]() paf是一个指向存放函数的数组指针  
int (*paf)[]() paf是一个指向存放返回值是int的函数的数组指针
                       //      (ILLEGAL)

int *(*pfp)();         //a pointer to a function returning an int pointer
(*pfp)()  pfp是一个指向函数的指针 
int *(*pfp)() pfp是一个指向返回值是int指针的函数指针

int (*pfa)()[];        //a pointer to a function returning an array of ints
(*pfa)() pfa是一个指向函数的指针 
(*pfa)()[] pfa是一个指向返回值是数组的函数指针 
int (*pfa)()[] pfa是一个指向返回值是存放int数组的函数指针
                       //      (ILLEGAL)

int (*pff)()();        //a pointer to a function returning a function
 (*pff)() pff是一个指向函数的指针  
(*pff)()() pff是一个指向返回值是函数的函数指针  
int (*pff)()() pff是一个指向返回值是 返回值为int的函数 的函数指针
                       //      returning an int (ILLEGAL)

int **app[];           //an array of pointers to int pointers
 app[] app是一个数组  
int **app[] app是一个存放指向int的指针的指针的数组

int (*apa[])[];        //an array of pointers to arrays of ints
 apa[] apa是一个数组  
(*apa[]) apa是一个存放指针的数组 
(*apa[])[] apa是一个存放 指向数组的指针 的数组 
int (*apa[])[] apa是一个存放 指向int数组的指针 的数组

int (*apf[])();        //an array of pointers to functions returning an int
*apf[] apf是一个存放指针的数组  
(*apf[])() apf是一个存放函数指针的数组 
int (*apf[])() apf是一个存放 返回值是int的函数指针的数组

int *aap[][];          //an array of arrays of int pointers
 aap[] app是一个数组 
aap[][] app是一个存放数组的数组 
int *aap[][] app是一个存放int指针的数组的数组

int aaa[][][];         //an array of arrays of arrays of ints
aaa[] aaa是一个数组 
aaa[][] aaa是一个存放数组的数组 
aaa[][][] aaa是一个存放数组的数组的数组 
int aaa[][][] aaa是一个存放int的数组的数组的数组

int aaf[][]();         //an array of arrays of functions returning an int
 aaf[][] aaf是一个存放数组的数组 
aaf[][]() aaf是一个存放函数的数组的数组 
int aaf[][]() aaf是一个存放返回值是int 的函数的数组的数组
                       //      (ILLEGAL)

int *afp[]();          //an array of functions returning int pointers (ILLEGAL)
 afp[]() afp是一个存放函数的数组  
int *afp[]() afp是一个存放返回值是int指针的函数的数组

int afa[]()[];         //an array of functions returning an array of ints
afa[]() afa是一个存放函数的数组 
afa[]()[] afa是一个存放返回值是数组的函数的数组  
int afa[]()[] afa是一个存放返回值是int数组的函数的数组
                       //      (ILLEGAL)

int aff[]()();         //an array of functions returning functions
aff[]() aff是一个存放函数的数组 
aff[]()() aff是一个存放返回值是函数的函数的数组 
int aff[]()() aff是一个存放返回值是int函数的函数的数组
                       //      returning an int (ILLEGAL)

int **fpp();           //a function returning a pointer to an int pointer
 fpp() fpp是函数 
int **fpp() fpp是一个返回值是指向int的指针的指针的函数

int (*fpa())[];        //a function returning a pointer to an array of ints
 (*fpa()) fpa是一个返回值是指针的函数 
(*fpa())[] fpa是一个返回值是指向数组的指针的函数 
int (*fpa())[] fpa是一个指向int数组的指针的函数

int (*fpf())();        //a function returning a pointer to a function
*fpf() fpf是返回值是指针的函数 
(*fpf())() fpf是一个返回值是函数的指针的函数 
int (*fpf())() fpf是一个返回值是int的函数的指针的函数
                       //      returning an int

int *fap()[];          //a function returning an array of int pointers (ILLEGAL)
fap()[]  fap是一个返回值是数组的函数 
int *fap()[]是一个返回值是int指针的数组的函数

int faa()[][];         //a function returning an array of arrays of ints
faa()[] faa是一个返回值是数组的函数 
faa()[][] faa是一个返回值是数组的数组的函数 
int faa()[][] faa是一个返回值是int的数组的数组的函数
                       //      (ILLEGAL)

int faf()[]();         //a function returning an array of functions
faf()[] faf是一个返回值是数组的函数 
faf()[]() faf是一个返回值是存放函数数组的函数 
int faf()[]() faf是一个返回值是存放 返回值是int函数 的数组的函数
                       //      returning an int (ILLEGAL)

int *ffp()();          //a function returning a function
ffp() ffp是一个函数 
ffp()() ffp是一个返回值是函数的函数 
int *ffp()() ffp是一个返回值是 int指针的函数 的函数
                       //      returning an int pointer (ILLEGAL)

char (*(*x())[])();
 x() x是一个函数 
(*x()) x是一个返回值是指针的函数 
(*x())[] x是一个返回值是指向数组的函数 
(*(*x())[]) x是一个返回值是指向 存放指针的数组 的函数 
(*(*x())[])() x是一个返回值是指向 存放函数的指针的数组 的函数 
char (*(*x())[])() x是一个返回值是指向 存放返回值是函数的指针的数组 的函数
    				  //x: function returning pointer to array[] of pointer to function returning char

char (*(*x[3])())[5];
    				  //x: array[3] of pointer to function returning pointer to array[5] of char
char (*(*x[])())[];
*x[] x是一个存放指针的数组 
(*x[])() x是一个存放函数的指针的数组 
(*(*x[])()) x是一个存放 返回值是指针的函数的指针 的数组 
(*(*x[])())[] x是一个存放 返回值是数组指针的函数的指针 的数组 
char (*(*x[])())[]x是一个存放 返回值是char数组指针的函数的指针 的数组

int i; //an int
//i是int类型

int *p; //an int pointer (ptr to an int)
//p是一个int型指针

int a[]; //an array of ints
//a是一个存放int的数组

int f(); //a function returning an int
//f是一个返回值是int的函数

int **pp; //a pointer to an int pointer (ptr to a ptr to an int)
//*pp是一个指针 int **pp 是指向int指针的指针

int (*pa)[]; //a pointer to an array of ints
(*pa) pa是一个指针
(*pa)[] pa指向数组
int (*pa)[] pa是一个指向int数组的指针

int (*pf)(); //a pointer to a function returning an int
(*pf)() pf是一个指向函数的指针
int (*pf)() pf是一个指向返回值是int函数的指针 – 函数指针

int *ap[]; //an array of int pointers (array of ptrs to ints)
ap[] ap是一个数组
int *ap[] ap是一个存放int指针的数组

int aa[][]; //an array of arrays of ints
aa[] aa是一个数组
aa[][] aa是一个每个位置都是数组的数组
int aa[][] aa是一个存放int的二维数组

int af; //an array of functions returning an int (ILLEGAL)
af[] af是一个数组
af 是一个存放函数的数组
int af af是一个存放返回值是int的函数的数组

int *fp(); //a function returning an int pointer
fp() fp是一个函数
int *fp() fp是一个返回值是int指针的函数

int fa()[]; //a function returning an array of ints (ILLEGAL)
fa()是一个函数 fa()[]fa是一个函数数组
int fa()[] fa是一个返回值是int数组的函数

int ff()(); //a function returning a function returning an int
ff() ff是一个函数
ff()() ff是一个返回函数的函数
int ff()() ff是一个返回值是int的函数的函数
// (ILLEGAL)
int ***ppp; //a pointer to a pointer to an int pointer
*ppp ppp是一个指针
**ppp ppp是一个指向指针的指针
int ***ppp ppp是一个指向int指针的指针的指针

int (**ppa)[]; //a pointer to a pointer to an array of ints
**ppa 是一个指向指针的指针
(**ppa)[] ppa是一个指向数组的指针的指针
int (**ppa)[] ppa是一个指向存放int数组的指针的指针

int (**ppf)(); //a pointer to a pointer to a function returning an int
**ppf ppf是一个指向指针的指针
(**ppf)() ppf是一个指向函数的指针的指针
int (**ppf)() ppf是一个指向返回值是int的函数的指针的指针

int *(*pap)[]; //a pointer to an array of int pointers
*pap pap是一个指针
(*pap)[] pap是一个指向数组的指针
int *(*pap)[] pap是一个指向存放int指针的数组指针

int (*paa)[][]; //a pointer to an array of arrays of ints
paa是一个指向存放int的数组的数组的指针

int (*paf); //a pointer to a an array of functions returning an int
(*paf)[] paf是一个指向数组的指针
(*paf) paf是一个指向存放函数的数组指针
int (*paf) paf是一个指向存放返回值是int的函数的数组指针
// (ILLEGAL)

int *(*pfp)(); //a pointer to a function returning an int pointer
(*pfp)() pfp是一个指向函数的指针
int *(*pfp)() pfp是一个指向返回值是int指针的函数指针

int (*pfa)()[]; //a pointer to a function returning an array of ints
(*pfa)() pfa是一个指向函数的指针
(*pfa)()[] pfa是一个指向返回值是数组的函数指针
int (*pfa)()[] pfa是一个指向返回值是存放int数组的函数指针
// (ILLEGAL)

int (*pff)()(); //a pointer to a function returning a function
(*pff)() pff是一个指向函数的指针
(*pff)()() pff是一个指向返回值是函数的函数指针
int (*pff)()() pff是一个指向返回值是 返回值为int的函数 的函数指针
// returning an int (ILLEGAL)

int **app[]; //an array of pointers to int pointers
app[] app是一个数组
int **app[] app是一个存放指向int的指针的指针的数组

int (*apa[])[]; //an array of pointers to arrays of ints
apa[] apa是一个数组
(*apa[]) apa是一个存放指针的数组
(*apa[])[] apa是一个存放 指向数组的指针 的数组
int (*apa[])[] apa是一个存放 指向int数组的指针 的数组

int (*apf[])(); //an array of pointers to functions returning an int
*apf[] apf是一个存放指针的数组
(*apf[])() apf是一个存放函数指针的数组
int (*apf[])() apf是一个存放 返回值是int的函数指针的数组

int *aap[][]; //an array of arrays of int pointers
aap[] app是一个数组
aap[][] app是一个存放数组的数组
int *aap[][] app是一个存放int指针的数组的数组

int aaa[][][]; //an array of arrays of arrays of ints
aaa[] aaa是一个数组
aaa[][] aaa是一个存放数组的数组
aaa[][][] aaa是一个存放数组的数组的数组
int aaa[][][] aaa是一个存放int的数组的数组的数组

int aaf[]; //an array of arrays of functions returning an int
aaf[][] aaf是一个存放数组的数组
aaf[] aaf是一个存放函数的数组的数组
int aaf[] aaf是一个存放返回值是int 的函数的数组的数组
// (ILLEGAL)

int *afp; //an array of functions returning int pointers (ILLEGAL)
afp afp是一个存放函数的数组
int *afp afp是一个存放返回值是int指针的函数的数组

int afa[]; //an array of functions returning an array of ints
afa afa是一个存放函数的数组
afa[] afa是一个存放返回值是数组的函数的数组
int afa[] afa是一个存放返回值是int数组的函数的数组
// (ILLEGAL)

int aff(); //an array of functions returning functions
aff aff是一个存放函数的数组
aff() aff是一个存放返回值是函数的函数的数组
int aff() aff是一个存放返回值是int函数的函数的数组
// returning an int (ILLEGAL)

int **fpp(); //a function returning a pointer to an int pointer
fpp() fpp是函数
int **fpp() fpp是一个返回值是指向int的指针的指针的函数

int (*fpa())[]; //a function returning a pointer to an array of ints
(*fpa()) fpa是一个返回值是指针的函数
(*fpa())[] fpa是一个返回值是指向数组的指针的函数
int (*fpa())[] fpa是一个指向int数组的指针的函数

int (*fpf())(); //a function returning a pointer to a function
*fpf() fpf是返回值是指针的函数
(*fpf())() fpf是一个返回值是函数的指针的函数
int (*fpf())() fpf是一个返回值是int的函数的指针的函数
// returning an int

int *fap()[]; //a function returning an array of int pointers (ILLEGAL)
fap()[] fap是一个返回值是数组的函数
int *fap()[]是一个返回值是int指针的数组的函数

int faa()[][]; //a function returning an array of arrays of ints
faa()[] faa是一个返回值是数组的函数
faa()[][] faa是一个返回值是数组的数组的函数
int faa()[][] faa是一个返回值是int的数组的数组的函数
// (ILLEGAL)

int faf(); //a function returning an array of functions
faf()[] faf是一个返回值是数组的函数
faf() faf是一个返回值是存放函数数组的函数
int faf() faf是一个返回值是存放 返回值是int函数 的数组的函数
// returning an int (ILLEGAL)

int *ffp()(); //a function returning a function
ffp() ffp是一个函数
ffp()() ffp是一个返回值是函数的函数
int *ffp()() ffp是一个返回值是 int指针的函数 的函数
// returning an int pointer (ILLEGAL)

char (*(*x())[])();
x() x是一个函数
(*x()) x是一个返回值是指针的函数
(x())[] x是一个返回值是指向数组的函数
((x())[]) x是一个返回值是指向 存放指针的数组 的函数
((x())[])() x是一个返回值是指向 存放函数的指针的数组 的函数
char ((*x())[])() x是一个返回值是指向 存放返回值是函数的指针的数组 的函数
//x: function returning pointer to array[] of pointer to function returning char

char (*(x[3])())[5];
//x: array[3] of pointer to function returning pointer to array[5] of char
char ((*x[])())[];
*x[] x是一个存放指针的数组
(x[])() x是一个存放函数的指针的数组
((x[])()) x是一个存放 返回值是指针的函数的指针 的数组
((x[])())[] x是一个存放 返回值是数组指针的函数的指针 的数组
char ((*x[])())[]x是一个存放 返回值是char数组指针的函数的指针 的数组

参考博客

https://blog.csdn.net/sooqing/article/details/1680700
https://blog.csdn.net/truefriend/article/details/1849427

老李头带你看世界
关注
C/C++开发人员要了解的几大著名C/C++开源库
dvlinker的技术专栏
07-24 1万+
本文详细讲述C/C++开发人员需要了解的几大著名C/C++开源库。
如何理解C和C++的复杂的声明
04-30
如何理解C和C++的复杂的声明如何理解C和C++的复杂的声明如何理解C和C++的复杂的声明如何理解C和C++的复杂的声明如何理解C和C++的复杂的声明如何理解C和C++的复杂的声明如何理解C和C++的复杂的声明如何理解C和C++的复杂的声明
C/C++ 复杂的声明
chenfeng0104的专栏
07-27 2254
入门阶段，看见类似void * (*(*fp1)(int))[10];的复杂声明，晕
C++ 中复杂的声明
weixin_33980459的博客
01-11 78
1、方法也是有类型的，方法的类型由返回类型和形参表决定。比如int F (int)的类型就是去掉方法名，int (int)。 2、对于方法类型，在返回类型和形参表之间，加上一个名称F，就表示一个特定的方法F。 3、思考，如果我在返回类型和形参表之间，加上一个指针变量呢？ 　　表示指向这一类方法的指针。即int (*P) (int)，需要特别注意的是，必须使用括号把*P括起来。如果没有括起来，...
C++ 理解复杂声明
qq_36402529的博客
01-10 170
C++ 理解复杂声明 本文转载于https://www.cnblogs.com/BinarySong/p/12913504.html C和C++中的复杂声明往往难以理解，这里为大家总结出理解它们的系统化方法。 前置知识 1.声明 C++标准对声明的定义是：声明规定名字将如何被解释。一个声明只解释一个名字。这个名字是声明的“主语”，是描述的中心，其余的名字都并非重点。例如： int fun(int a); 这个声明包含两个名字fun和a。然而只有fun是“主语”。后面的部分会阐述如何确定这唯一的“主语”。
c++复杂声明
Keith
10-12 437
void (*funcPtr)();上面声明了一个指向函数的指针，当碰到这样一个比较复杂的声明时，最好的方法是从 中间开始和向外扩展： 从中间开始：即 从变量名开始 像外扩展：即 先注意右边最近的项，已右括号结束，再注意左边的项，已左括号结束，再注意右边的项。。。 用上述方法来解析一下第一个声明： 往右看：是右括号，结束 往左看：funcPtr是个指针 往左看：碰到左括号，结束 往右看：指针指向一个
C/C++编程笔记：C语言中的复杂声明分析，用实例带你完全读懂
致力于C语言C++知识分享！
11-11 238
大多数时候，声明很容易阅读，但是很难读取一些涉及函数指针的声明。 例如，考虑“ signal.h”中的以下声明。 void(*bsd_signal(int, void(*)(int)))(int); 让我们看看读取复杂声明的步骤： 1）将C声明转换为后缀格式，并从右向左读取。 2）要将表达式转换为后缀，请从最里面的括号开始，如果不存在最里面的括号，则从声明名称开始，然后右移。第一次遇到结尾括号时，请向左走。解析完整个括号后，便会从括号中出来。 3）继续直到解析完完整的声明。 让我们从简..
C++中怎么读懂复杂的类型声明
HWQlet的博客
04-19 570
这是我从学长那学到的：他的网站链接 int **ptr，这个大家应该都能够知道什么意思：ptr是指向(int类型指针)的指针，可以用于创建二维数组 但是看看这个： int *(*(**foo[][5])())[]; 是不是看着都头疼，对于这种代码，需要有方法去读懂它。 C++中类型声明都有basic Type（基本类型）和derived Type（派生类型） Basic Type(基...
IAR C/C++ Development Guide
09-27
《IAR C/C++开发指南》中包含了版权信息和免责声明。这些声明明确指出文档内容未经IAR Systems AB的书面同意，不得复制和分发。另外，文档中提供的信息可能会变化，并不代表IAR Systems对信息的准确性和完整性做出...
AVI.zip_C/C++__C/C++_
08-09
它与C/C++结合，可以让开发者编写自定义的脚本来扩展WinCC的功能，比如创建复杂的数据逻辑、报警处理或者实现特定的通信协议。 在“Indirect Adressing of Variables in WinCC”这个场景下，可能涉及到的是如何在...
材料.rar_C/C++__C/C++_
08-09
C/C++是两种广泛使用的编程语言，C语言是基础，而C++是在C的基础上扩展了面向对象编程的概念。在数学建模竞赛中，参赛者通常需要编写高效的算法来处理复杂的数学问题，C/C++因其执行效率高、控制性强的特点，常被...
C/C++指针经典资料大全
01-21
在IT领域，C和C++语言中的指针是至关重要的概念，它们是程序设计的基础，也是许多高级技术的基石。本资源包“C/C++指针经典资料大全”收集了多部经典教材，旨在帮助学习者深入理解并掌握指针的使用。 1. **指针基础...
C/C++：如何理解复杂的声明
经营人生
10-28 1656
  这里说的声明，不光适用于C/C++，其他的一些语言也能适用。与java和 C#等不同，声明和定义在C/C++中有着比较明显的区别：声明仅仅是介绍名字（introduce names），而定义则会为该名字分配相应的空间。打个通俗的比喻：声明就是你在谈话中提到某个人的名字，而定义就是把你提到的这个人带到谈话的人群中 来，让大家见识一下他/她是什么样子。这里主要介绍声明。在C中，声明的形式为（d
C复杂声明
06-04 3703
C语言所有复杂的指针声明，都是由各种声明嵌套构成的。如何解读复杂指针声明呢？右左法则是一个既著名又常用的方法。不过，右左法则其实并不是C标准里面的内容，它是从C标准的声明规定中归纳出来的方法。C标准的声明规则，是用来解决如何创建声明的，而右左法则是用来解决如何辩识一个声明的，两者可以说是相反的。右左法则的英文原文是这样说的： The right-left rule: Start reading the declaration from the innermost parentheses, go right,
C++中复杂声明的理解
weixin_43412666的博客
08-14 191
C++中复杂声明   记录一下自己对复杂声明的理解，有一个基本原则：由（括号）内向（括号）外，由左至右。   目前遇到的基本都是指针、引用和数组这三个类型混杂在一起的情况，在最开始没了解规律的时候，很头大。了解的有两种情况，如下。   1、指向指针的引用 int i = 0; int *p; int *&r = p;//r为指针p的引用   上面代码的第三行中，由于没有括号，所以直接从右至左读即可，r的左边为&，所以r是一个引用，然后再接着往左读，看r是一个什么引用，int
C++复杂声明的解读
dalinthegreat的专栏
08-12 282
C++复杂声明的解读 1.指针的引用 在C++ Primer中说：面对比较复杂的指针或引用的声明语句时，最简单的办法是从右向左读。比如： int i = 42; int *p; int *&r = p; ​ r = &i; *r = 0; 如上面的代码(int *&r = p)，r的左边是&，所以r是引用，再右边是*，所以r引用的是指针，最左边是int，所...
C/C++中复杂的申明
笨笨的专栏
09-02 282
昨天一朋友(估计要考二级了)问我: int * a[]; 这玩意儿到底是指针还是数组. 我告诉他, 这是数组, 里 面放的是 指针. 不过我怕他又问相似的, 所以就告诉他"读"的方法 我想可能会对C,或者C++的初学者有用, 所以就发在这里了. 高手请不要笑哦! 先来几个简单的 [code="c"] int a; // 一个整形 int ...
C复杂声明解析
selooloo的专栏
12-20 995
C语言所有复杂的指针声明，都是由各种声明嵌套构成的。如何解读复杂指针声明呢？右左法则是一个既著名又常用的方法。不过，右左法则其实并不是C标准里面的内容，它是从C标准的声明规定中归纳出来的方法。C标准的声明规则，是用来解决如何创建声明的，而右左法则是用来解决如何辩识一个声明的，两者可以说是相反的。右左法则的英文原文是这样说的：The right-left rule: Start reading
C语言16--宏定义和关键字
最新发布
weixin_69902486的博客
09-12 987
理解宏定义与关键字不仅有助于提高我们的编程技巧，还能让我们更有效地优化和简化代码。
解析C/C++复杂声明：从入门到深入理解
本文旨在帮助读者深入理解C/C++中的复杂声明，从日常遇到的基础概念开始，逐步讲解const修饰符、typedef和函数指针。作者强调，虽然复杂的声明在编程实践中并不推荐，但掌握它们有助于解决实际问题。首先，文章从...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

老李头带你看世界

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值