C语言关于取值和取址
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了C语言关于取值和取址相关的知识，希望对你有一定的参考价值。
1、首先打开Visual C++，点击左上角“文件”菜单按钮，并点击“新建”按钮。在弹出的窗口中首先选择“文件”选项卡，在左侧列表中选取“C++ Source File”项。
2、在右侧文件名文本框中输入文件名，如“demo”等。
3、然后按照图片输入演示代码。
4、代码运行：按照箭头标识的顺序，依次点击箭头所指向的按钮。
5、按下最后一个按钮成功后会弹出图所示黑色窗体，窗体中显示程序运行结果，并得出正确数值。
当然你也可以用取值符号(*)取任何变量，程序就会自动吧这个变量内的数据作为地址去获取，这个地址的数据，这样是非常危险，容易造成溢出或者任何不可预知的灾难。
任何变量都是放在内存中的,取址符号(&)就是获得他们在内存中地址，记得指针也是以变量，没有任何特殊，就看你怎么使用它，你把它当指针就是指针，当普通变量就是普通变量。
#include "stdio.h"
main()
int a=2;
int b =33;
int *c = &b;
printf("%d\n",c); /获取c变量内装的数据, 也就是c指向的地址
printf("%d\n",*c); //指针取值，获取c指向的这个地址所储存的值
printf("%d\n",&c); //记得c是个变量本质和任何变量没差别，这里取得c变量的地址。
printf("-----------")
printf("%d\n",a); //获取a这个变量内装的数据
//printf("%d\n",*a); 这句是错的 变量不能用取值符
printf("%d\n",&a);//这里取得a变量的地址。
参考技术B int a,c;
int *b;
a=1;
b=&a; //取a的地址
c=*b; //取b指向的值，即a; 参考技术C 0是常量
a和*p表示的都是整形左值，p和&a表示的都是指针型左值，1和0x1000表示整形和指针型右值。（左右值的概念不清的话，google一下）
在内存中，a和p有存储空间空间，a存放着1，p存放着0x1000，*p和&a没有空间，他们的运算结果是在寄存器中存放的，1和0x1000也有空间，在程序的常量段存放。
*p按照Stanley Lippman的著作《C++ Primer》中的描述，p是指针变量，*是解引用操作符，*p是一个表达式，含义是“对指针变量p进行解引用操作”，这与表达式&a的含义“取整形变量a的地址”是正好是相反的操作。
C 语言高效编程与代码优化
C 语言高效编程与代码优化）
程序优化最重要的就是找出待优化的地方，也就是找出程序的哪些部分或者哪些模块运行缓慢亦或消耗大量的内存。只有程序的各部分经过了优化，程序才能执行的更快。程序中运行最多的部分，特别是那些被程序内部循环重复调用的方法最该被优化。
整形数
如果我们确定整数非负，就应该使用unsigned int而不是int。有些处理器处理无符号unsigned 整形数的效率远远高于有符号signed整形数（这是一种很好的做法，也有利于代码具体类型的自解释）。
因此，在一个紧密循环中，声明一个int整形变量的最好方法是：
register unsigned int variable_name;
记住，整形in的运算速度高浮点型float，并且可以被处理器直接完成运算，而不需要借助于FPU（浮点运算单元）或者浮点型运算库。尽管这不保证编译器一定会使用到寄存器存储变量，也不能保证处理器处理能更高效处理unsigned整型，但这对于所有的编译器是通用的。
例如在一个计算包中，如果需要结果精确到小数点后两位，我们可以将其乘以100，然后尽可能晚的把它转换为浮点型数字。
除法和取余数
在标准处理器中，对于分子和分母，一个32位的除法需要使用20至140次循环操作。除法函数消耗的时间包括一个常量时间加上每一位除法消耗的时间。
Time (numerator / denominator) = C0 + C1* log2 (numerator / denominator)
= C0 + C1 * (log2 (numerator) - log2 (denominator)).
a=a%8;
// 可以改为：
a=a&7; // 位操作只需一个指令周期即可完成
对于ARM处理器，这个版本需要20+4.3N次循环。这是一个消耗很大的操作，应该尽可能的避免执行。有时，可以通过乘法表达式来替代除法。例如，假如我们知道b是正数并且b*c是个整数，那么(a/b)>c可以改写为a>(c*b)。如果确定操作数是无符号unsigned的，使用无符号unsigned除法更好一些，因为它比有符号signed除法效率高。
- 避免不必要的整数除法
// 不好的代码： int i， j， k， m； m = i / j / k； // 推荐的代码： int i， j， k， m； m = i / (j * k)；
合并除法和取余数
在一些场景中，同时需要除法（x/y）和取余数（x%y）操作。这种情况下，编译器可以通过调用一次除法操作返回除法的结果和余数。如果既需要除法的结果又需要余数，我们可以将它们写在一起，如下所示：
int func_div_and_mod (int a, int b)
return (a / b) + (a % b);
通过2的幂次进行除法和取余数
如果除法中的除数是2的幂次，我们可以更好的优化除法。编译器使用移位操作来执行除法。因此，我们需要尽可能的设置除数为2的幂次（例如64而不是66）。并且依然记住，无符号unsigned整数除法执行效率高于有符号signed整形出发。
typedef unsigned int uint;
uint div32u (uint a)
return a / 32;
int div32s (int a)
return a / 32;
上面两种除法都避免直接调用除法函数，并且无符号unsigned的除法使用更少的计算机指令。由于需要移位到0和负数，有符号signed的除法需要更多的时间执行。
取模的一种替代方法
我们使用取余数操作符来提供算数取模。但有时可以结合使用if语句进行取模操作。考虑如下两个例子：
uint modulo_func1 (uint count)
return (++count % 60);
uint modulo_func2 (uint count)
if (++count >= 60)
count = 0;
return (count);
优先使用if语句，而不是取余数运算符，因为if语句的执行速度更快。这里注意新版本函数只有在我们知道输入的count结余0至59时在能正确的工作。
使用数组下标
如果你想给一个变量设置一个代表某种意思的字符值，你可能会这样做：
switch ( queue )
case 0 : letter = 'W';
break;
case 1 : letter = 'S';
break;
case 2 : letter = 'U';
break;
或者这样做：
if ( queue == 0 )
letter = 'W';
else if ( queue == 1 )
letter = 'S';
else
letter = 'U';
一种更简洁、更快的方法是使用数组下标获取字符数组的值。如下：
static char *classes="WSU";
letter = classes[queue];
全局变量
全局变量绝不会位于寄存器中。使用指针或者函数调用，可以直接修改全局变量的值。因此，编译器不能将全局变量的值缓存在寄存器中，但这在使用全局变量时便需要额外的（常常是不必要的）读取和存储。所以，在重要的循环中我们不建议使用全局变量。
如果函数过多的使用全局变量，比较好的做法是拷贝全局变量的值到局部变量，这样它才可以存放在寄存器。这种方法仅仅适用于全局变量不会被我们调用的任意函数使用。例子如下：
int f(void);
int g(void);
int errs;
void test1(void)
errs += f();
errs += g();
void test2(void)
int localerrs = errs;
localerrs += f();
localerrs += g();
errs = localerrs;
注意，test1必须在每次增加操作时加载并存储全局变量errs的值，而test2存储localerrs于寄存器并且只需要一个计算机指令。
使用别名
考虑如下的例子：
void func1( int *data )
int i;
for(i=0; i<10; i++)
anyfunc( *data, i);
尽管*data的值可能从未被改变，但编译器并不知道anyfunc函数不会修改它，所以程序必须在每次使用它的时候从内存中读取它。如果我们知道变量的值不会被改变，那么就应该使用如下的编码：
void func1( int *data )
int i;
int localdata;
localdata = *data;
for(i=0; i<10; i++)
anyfunc ( localdata, i);
这为编译器优化代码提供了条件。
变量的生命周期分割
由于处理器中寄存器是固定长度的，程序中数字型变量在寄存器中的存储是有一定限制的。
有些编译器支持“生命周期分割”（live-range splitting），也就是说在程序的不同部分，变量可以被分配到不同的寄存器或者内存中。变量的生命周期开始于对它进行的最后一次赋值，结束于下次赋值前的最后一次使用。在生命周期内，变量的值是有效的，也就是说变量是活着的。不同生命周期之间，变量的值是不被需要的，也就是说变量是死掉的。这样，寄存器就可以被其余变量使用，从而允许编译器分配更多的变量使用寄存器。
需要使用寄存器分配的变量数目需要超过函数中不同变量生命周期的个数。如果不同变量生命周期的个数超过了寄存器的数目，那么一些变量必须临时存储于内存。这个过程就称之为分割。
编译器首先分割最近使用的变量，用以降低分割带来的消耗。禁止变量生命周期分割的方法如下：
- 限定变量的使用数量：这个可以通过保持函数中的表达式简单、小巧、不使用太多的变量实现。将较大的函数拆分为小而简单的函数也会达到很好的效果。
- 对经常使用到的变量采用寄存器存储：这样允许我们告诉编译器该变量是需要经常使用的，所以需要优先存储于寄存器中。然而，在某种情况下，这样的变量依然可能会被分割出寄存器。
变量类型
C编译器支持基本类型：char、short、int、long(包括有符号signed和无符号unsigned）、float和double。使用正确的变量类型至关重要，因为这可以减少代码和数据的大小并大幅增加程序的性能。
局部变量
我们应该尽可能的不使用char和short类型的局部变量。对于char和short类型，编译器需要在每次赋值的时候将局部变量减少到8或者16位。这对于有符号变量称之为有符号扩展，对于无符号变量称之为零扩展。这些扩展可以通过寄存器左移24或者16位，然后根据有无符号标志右移相同的位数实现，这会消耗两次计算机指令操作（无符号char类型的零扩展仅需要消耗一次计算机指令）。
可以通过使用int和unsigned int类型的局部变量来避免这样的移位操作。这对于先加载数据到局部变量，然后处理局部变量数据值这样的操作非常重要。无论输入输出数据是8位或者16位，将它们考虑为32位是值得的。
考虑下面的三个函数：
int wordinc (int a)
return a + 1;
short shortinc (short a)
return a + 1;
char charinc (char a)
return a + 1;
尽管结果均相同，但是第一个程序片段运行速度高于后两者。
指针
我们应该尽可能的使用引用值的方式传递结构数据，也就是说使用指针，否则传递的数据会被拷贝到栈中，从而降低程序的性能。我曾见过一个程序采用传值的方式传递非常大的结构数据，然后这可以通过一个简单的指针更好的完成。
函数通过参数接受结构数据的指针，如果我们确定不改变数据的值，我们需要将指针指向的内容定义为常量。例如：
void print_data_of_a_structure ( const Thestruct *data_pointer)
...printf contents of the structure...
这个示例告诉编译器函数不会改变外部参数的值（使用const修饰），并且不用在每次访问时都进行读取。同时，确保编译器限制任何对只读结构的修改操作从而给予结构数据额外的保护。
对于大部分的编译器，使用指针比使用数组生成的代码更短，执行效率更高。
许多种情况下，可以用指针运算代替数组索引，这样做常常能产生又快又短的代码。与数组索引相比，指针一般能使代码速度更快，占用空间更少。使用多维数组时差异更明显。
指针链
指针链经常被用于访问结构数据。例如，常用的代码如下：
typedef struct int x, y, z; Point3;
typedef struct Point3 *pos, *direction; Object;
void InitPos1(Object *p)
p->pos->x = 0;
p->pos->y = 0;
p->pos->z = 0;
然而，这种的代码在每次操作时必须重复调用p->pos，因为编译器不知道p->pos->x与p->pos是相同的。一种更好的方法是缓存p->pos到一个局部变量：
void InitPos2(Object *p)
Point3 *pos = p->pos;
pos->x = 0;
pos->y = 0;
pos->z = 0;
另一种方法是在Object结构中直接包含Point3类型的数据，这能完全消除对Point3使用指针操作。
条件执行
条件执行语句大多在if语句中使用，也在使用关系运算符（<，==，>等）或者布尔值表达式（&&，！等）计算复杂表达式时使用。对于包含函数调用的代码片段，由于函数返回值会被销毁，因此条件执行是无效的。
因此，保持if和else语句尽可能简单是十分有益处的，因为这样编译器可以集中处理它们。关系表达式应该写在一起。
下面的例子展示编译器如何使用条件执行：
int g(int a, int b, int c, int d)
if (a > 0 && b > 0 && c < 0 && d < 0)
// grouped conditions tied up together//
return a + b + c + d;
return -1;
由于条件被聚集到一起，编译器能够将他们集中处理。
布尔表达式和范围检查
一个常用的布尔表达式是用于判断变量是否位于某个范围内，例如，检查一个图形坐标是否位于一个窗口内：
bool PointInRectangelArea (Point p, Rectangle *r)
return (p.x >= r->xmin && p.x < r->xmax &&
p.y >= r->ymin && p.y < r->ymax);
这里有一种更快的方法：x>min && x<max可以转换为(unsigned)(x-min)<(max-min)。这对于min等于0时更为有益。优化后的代码如下：
bool PointInRectangelArea (Point p, Rectangle *r)
return ((unsigned) (p.x - r->xmin) < r->xmax &&
(unsigned) (p.y - r->ymin) < r->ymax);
布尔表达式和零值比较
处理器的标志位在比较指令操作后被设置。标志位同样可以被诸如MOV、ADD、AND、MUL等基本算术和裸机指令改写。如果数据指令设置了标志位，N和Z标志位也将与结果与0比较一样进行设置。N标志表示结果是否是负值，Z标志表示结果是否是0。
C语言中，处理器中的N和Z标志位与下面的指令联系在一起：有符号关系运算x<0，x>=0，x0，x!=0；无符号关系运算x0，x!=0（或者x>0）。
C代码中每次关系运算符的调用，编译器都会发出一个比较指令。如果操作符是上面提到的，编译器便会优化掉比较指令。例如：
int aFunction(int x, int y)
if (x + y < 0)
return 1;
else
return 0;
尽可能的使用上面的判断方式，这可以在关键循环中减少比较指令的调用，进而减少代码体积并提高代码性能。C语言没有借位和溢出位的概念，因此，如果不借助汇编，不可能直接使用借位标志C和溢出位标志V。但编译器支持借位（无符号溢出），例如：
int sum(int x, int y)
int res;
res = x + y;
if ((unsigned) res < (unsigned) x) // carry set? //
res++;
return res;
懒检测开发
在if(a>10 && b=4)这样的语句中，确保AND表达式的第一部分最可能较快的给出结果（或者最早、最快计算），这样第二部分便有可能不需要执行。
用switch()函数替代if…else…
对于涉及if…else…else…这样的多条件判断，例如：
if( val == 1)
dostuff1();
else if (val == 2)
dostuff2();
else if (val == 3)
dostuff3();
使用switch可能更快：
switch( val )
case 1: dostuff1(); break;
case 2: dostuff2(); break;
case 3: dostuff3(); break;
在if()语句中，如果最后一条语句命中，之前的条件都需要被测试执行一次。Switch允许我们不做额外的测试。如果必须使用if…else…语句，将最可能执行的放在最前面。
二分中断
使用二分方式中断代码而不是让代码堆成一列，不要像下面这样做：
if(a==1)
else if(a==2)
else if(a==3)
else if(a==4)
else if(a==5)
else if(a==6)
else if(a==7)
else if(a==8)
使用下面的二分方式替代它，如下：
if(a<=4)
if(a==1)
else if(a==2)
else if(a==3)
else if(a==4)
else
if(a==5)
else if(a==6)
else if(a==7)
else if(a==8)
或者如下：
if(a<=4)
if(a<=2)
if(a==1)
/* a is 1 */
else
/* a must be 2 */
else
if(a==3)
/* a is 3 */
else
/* a must be 4 */
else
if(a<=6)
if(a==5)
/* a is 5 */
else
/* a must be 6 */
else
if(a==7)
/* a is 7 */
else
/* a must be 8 */
switch语句vs查找表
Switch的应用场景如下：
- 调用一到多个函数
- 设置变量值或者返回一个值
- 执行一到多个代码片段
如果case标签很多，在switch的前两个使用场景中，使用查找表可以更高效的完成。例如下面的两种转换字符串的方式：
char * Condition_String1(int condition)
switch(condition)
case 0: return "EQ";
case 1: return "NE";
case 2: return "CS";
case 3: return "CC";
case 4: return "MI";
case 5: return "PL";
case 6: return "VS";
case 7: return "VC";
case 8: return "HI";
case 9: return "LS";
case 10: return "GE";
case 11: return "LT";
case 12: return "GT";
case 13: return "LE";
case 14: return "";
default: return 0;
char * Condition_String2(int condition)
if ((unsigned) condition >= 15) return 0;
return
"EQ\\0NE\\0CS\\0CC\\0MI\\0PL\\0VS\\0VC\\0HI\\0LS\\0GE\\0LT\\0GT\\0LE\\0\\0" +
3 * condition;
第一个程序需要240 bytes，而第二个仅仅需要72 bytes。
循环
循环是大多数程序中的常用的结构；程序执行的大部分时间发生在循环中，因此十分值得在循环执行时间上下一番功夫。
-
循环终止
如果不加注意，循环终止条件的编写会导致额外的负担。我们应该使用计数到零的循环和简单的循环终止条件。简单的终止条件消耗更少的时间。看下面计算n！的两个程序。第一个实现使用递增的循环，第二个实现使用递减循环。int fact1_func (int n) int i, fact = 1; for (i = 1; i <= n; i++) fact *= i; return (fact); int fact2_func(int n) int i, fact = 1; for (i = n; i != 0; i--) fact *= i; return (fact);第二个程序的fact2_func执行效率高于第一个。
-
更快的for()循环
这是一个简单而高效的概念。通常，我们编写for循环代码如下：for( i=0; i<10; i++) ...i从0循环到9。如果我们不介意循环计数的顺序，我们可以这样写：
for( i=10; i--; ) ...这样快的原因是因为它能更快的处理i的值–测试条件是：i是非零的吗？如果这样，递减i的值。对于上面的代码，处理器需要计算“计算i减去10，其值非负吗？如果非负，i递增并继续”。简单的循环却有很大的不同。这样，i从9递减到0，这样的循环执行速度更快。
这里的语法有点奇怪，但确实合法的。循环中的第三条语句是可选的（无限循环可以写为for(;😉）。如下代码拥有同样的效果：
for(i=10; i; i--)或者更进一步的：
for(i=10; i!=0; i--)这里我们需要记住的是循环必须终止于0（因此，如果在50到80之间循环，这不会起作用），并且循环计数器是递减的。使用递增循环计数器的代码不享有这种优化。
-
合并循环
如果一个循环能解决问题坚决不用二个。但如果你需要在循环中做很多工作，这坑你并不适合处理器的指令缓存。这种情况下，两个分开的循环可能会比单个循环执行的更快。下面是一个例子：//Original Code : for(i=0; i<100; i++) stuff以上是关于C语言关于取值和取址的主要内容，如果未能解决你的问题，请参考以下文章