现在的位置: 首页 > 综合 > 正文

C语言要点

2014年01月20日 ⁄ 综合 ⁄ 共 3492字 ⁄ 字号 评论关闭

一关键字:

1.      
static

第一个作用:修饰变量。变量又分为局部和全局变量,但它们都存在内存的静态区。由于被 static修饰的变量总是存在内存的静态区,所以即使这个函数运行结束,这个静态变量的值还是不会被销毁,函数下次使用时仍然能用到这个值。

static int j;

void fun1void

{

static int i = 0;

i++;

}

void fun2void

{

j=0;

j++;

}

int main()

{

for(k=0; k<10; k++)

{

fun1();

fun2();

}

return 0;

第二个作用:修饰函数。函数前加 static使得函数成为静态函数。但此处“static”的含义不是指存储方式,而是指对函数的作用域仅局限于本文件(所以又称内部函数)。使用内部函数的好处是:不同的人编写不同的函数时,不用担心自己定义的函数,是否会与其它文件中的函数同名。

2 .sizeof

         sizeof是关键字不是函数

3. signedunsigned关键字

4. float变量与“零值”进行比较

5.if else语句

         先处理正常情况,再处理异常情况。

6.循环语句风格

         在多重循环中,如果有可能,应当将最长的循环放在最内层,最短的循环放

在最外层,以减少 CPU
跨切循环层的次数。

7. void

         void不能代表一个真实的变量

         void a; //错误

function(void a); //错误

8.const

         const修饰的只读变量必须在定义的同时初始化,编译器通常不为普通 const只读变量分配存储空间,而是将它们保存在符号表中,这使得它成为一个编译期间的值,没有了存储与读内存的操作,使得它的效率也很高。

         a)修饰指针

const int *p; // p 可变,p指向的对象不可变

int const *p; // p可变,p指向的对象不可变

int*const p; //p不可变,p指向的对象可变

const int *const p; //指针 p p指向的对象都不可变

b)修饰函数参数

const修饰符也可以修饰函数的参数,当不希望这个参数值被函数体内意外改变时使

用。例如:

void Fun(const int i);

9.extern

         extern就相当于他们的这些区别于中国人的特性。extern可以置于变量或者函数前,以

标示变量或者函数的定义在别的文件中。

        

10.struct

         空结构体的大小就定位 1bytestruct的成员默认情况下属性是
public
的,而class成员却是 private的。

11.union

         union维护足够的空间来置放多个数据成员中的“一种”,而不是为每一个数据成员配置空间,在union中所有的数据成员共用一个空间,同一时间只能储存其中一个数据成员,所有的数据成员具有相同的起始地址。例子如下:

union StateMachine

{

char character;

int number;

char *str;

double exp;

};

一个 union只配置一个足够大的空间以来容纳最大长度的数据成员.

 

12 typedef

        

 

 

二预处理

1.#if

         #if 的一般含义是如果#if后面的常量表达式为true,则编译它与#endif之间的代码,否则跳过这些代码。命令#endif
标识一个#if块的结束。#else命令的功能有点象 C语言中的 else
#else建立另一选择(在#if
失败的情况下)。#elif命令意义与 else if
相同,它形成一个 if else-if阶梯状语句,可进行多种编译选择。

 

2.#define

         #define会原样替换,要搞定它其实很简单,别吝啬括号就行了。

例子:

定义一个宏函数,求 x
的平方:

#define SQR (x) x * x

试试:假设 x
的值为10SQR (x)被替换后变成 10*10。没有问题。

再试试:假设 x
的值是个表达式10+1SQR (x)被替换后变成10+1*10+1。问题

这并不是我想要得到的。怎么办?括号括起来不就完了?

#define SQR (x) ((x*x))

        

三指针和数组

         注意!!!:指针的偏移值是起始地址加上指针指向对象的size

         1.数组名a作为左值和右值的区别

         数组名不能作为左值,对指针进行加 1操作,得到的是下一个元素的地址,而不是原有地址值直接加 1。所以,一个类型为 T的指针的移动,以
sizeof(T)
为移动单位。    main()

{

int a[5]={1,2,3,4,5};

int *ptr=(int *)(&a+1);

printf("%d,%d",*(a+1),*(ptr-1));

}

&a + 1: 取数组 a的首地址,该地址的值加上 sizeof(a)
的值,即 &a + 5*sizeof(int),也

就是下一个数组的首地址,显然当前指针已经越过了数组的界限。(int *)(&a+1):则是把上一步计算出来的地址,强制转换为 int *
类型,赋值给 ptr*(a+1): a,&a的值是一样的,但意思不一样,a是数组首元素的首地址,也就是 a[0]的首地址,&a是数组的首地址,a+1是数组下一元素的首地址,即a[1]的首地址,&a+1是下一个数组的首地址。所以输出
2*(ptr-1):
因为 ptr 是指向 a[5],并且 ptr int *
类型,所以 *(ptr-1)是指向 a[4]
,输出 5

 

2.数组和指针的关系

文件 1中定义如下:

char a[100];

文件 2 中声明如下:

extern char *a;

这里,文件1 中定义了数组a,文件2中声明它为指针。这有什么问题吗?平时不是总说数组与指针相似,甚至可以通用吗?但是,很不幸,这是错误的。通过上面的分析我们也能明白一些,数组就是数组,指针就是指针,它们是完全不同的两码事!他们之间没有任何关系,只是经常穿着相似的衣服来迷惑你罢了。下面就来分析分析这个问题:

 

定义和声明之间的区别,定义分配的内存,而声明没有。定义只能出现一次,而声明可以出现多次。这里extern告诉编译器 a这个名字已经在别的文件中被定义了,下面的代码使用的名字 a是别的文件定义的。再回顾到前面对于左值和右值的讨论,我们知道如果编译器需要某个地址(可能还需要加上偏移量)来执行某种操作的话,它就可以直接通过开锁动作(使用“*”这把钥匙)来读或者写这个地址上的内存,并不需要先去找到储存这个地址的地方。相反,对于指针而言,必须先去找到储存这个地址的地方,取出这个地址值然后对这个地址进行开锁(使用“*”这把钥匙)。如下图:

这就是为什么 extern char a[] extern char a[100]等价的原因。因为这只是声明,不分配空间,所以编译器无需知道这个数组有多少个元素。这两个声明都告诉编译器 a是在别的文件中被定义的一个数组,a
同时代表着数组 a的首元素的首地址,也就是这块内存的起始地址。数组内地任何元素的的地址都只需要知道这个地址就可以计算出来。

但是,当你声明为 extern char *a时,编译器理所当然的认为 a是一个指针变量,在 32位系统下,占 4byte。这
4
byte里保存了一个地址,这个地址上存的是字符类型数据。虽然在文件 1中,编译器知道a
是一个数组,但是在文件 2中,编译器并不知道这点。大多数编译器是按文件分别编译的,编译器只按照本文件中声明的类型来处理。所以,虽然a实际大小为 100byte,但是在文件
2
中,编译器认为a 只占4byte

我们说过,编译器会把存在指针变量中的任何数据当作地址来处理。所以,如果需要

访问这些字符类型数据,我们必须先从指针变量 a中取出其保存的地址。如下图:

 

显然,按照上面的分析,我们把文件 1中定义的数组在文件2
中声明为指针会发生错误。同样的,如果在文件 1中定义为指针,而在文件中声明为数组也会发生错误:

文件 1

char *p = “abcdefg”;

文件 2

extern char p[];

在文件 1 中,编译器分配4byte空间,并命名为 p。同时p里保存了字符串常量“abcdefg”的首字符的首地址。这个字符串常量本身保存在内存的静态区,其内容不可更改。在文件
2
中,编译器认为 p是一个数组,其大小为 4
byte,数组内保存的是 char类型的数据。在文件 2中使用p
的过程如下图:

 

3. 数组参数与指针参数

无法向函数传递一个数组,C语言中,当一维数组作为函数参数的时候,编译器总是把它解析成一个指向其首元素首地址的指针。

 

抱歉!评论已关闭.