笔记整理--C语言

让C程序更高效的10种方法

2011/08/04 | 分类：程序员 | 6 条评论 | 标签： C语言, 代码, 程序员

分享到：更多 0

代码之美，不仅在于为一个给定问题找到解决方案，而且还在代码的简单性、有效性、紧凑性和效率（内存）。代码设计比实际执行更难。因此，每一个程序员当用C语言编程时，都应该记着这些东西。本文向你介绍规范你的C代码的10种方法。

0. 避免不必要的函数调用

考虑下面的2个函数：

void str_print( char *str ) 
  
{ 
  
    int i; 
  
    for ( i = 0; i < strlen ( str ); i++ ) { 
  
        printf("%c",str[ i ] ); 
  
    } 
  
} 
void str_print1 ( char *str ) 
  
{ 
  
    int len; 
  
    len = strlen ( str ); 
  
    for ( i = 0; i < len; i++ ) { 
  
        printf("%c",str[ i ] ); 
  
    } 
  
}

请注意 这两个函数的功能相似。然而，第一个函数调用strlen（）函数多次，而第二个函数只调用函数strlen（）一次。因此第二个函数性能明显比第一个好。

1、避免不必要的内存引用

这次我们再用2个例子来对比解释：

int multiply ( int *num1 , int *num2 ) 
  
{ 
  
    *num1 = *num2; 
  
    *num1 += *num2; 
  
    return *num1; 
  
} 
int multiply1 ( int *num1 , int *num2 ) 
  
{ 
  
    *num1 = 2 * *num2; 
  
    return *num1; 
  
}

同样，这两个函数具有类似的功能。所不同的是在第一个函数（ 1 for reading *num1 , 2 for reading *num2 and 2 for writing to *num1）有5个内存的引用，而在第二个函数是只有2个内存引用（one for reading *num2 and one for writing to *num1）。现在你认为哪一个好些？

2、节约内存（内存对齐和填充的概念）

struct { 
  
    char c; 
  
    int i; 
  
    short s; 
  
}str_1; 
struct { 
  
    char c; 
  
    short s; 
  
    int i; 
  
}str_2;

假设一个字符需要1个字节，short占用2个字节和int需要4字节的内存。起初，我们会认为上面定义的结构是相同的，因此占据相同数量的内存。然而，而str_1占用12个字节，第二个结构只需要8个字节？这怎么可能呢？

请注意，在第一个结构，3个不同的4个字节被分配到三种数据类型，而在第二个结构的前4个自己char和short可以被采用，int可以采纳在第二个的4个字节边界（一共8个字节）。

3、使用无符号整数，而不是整数的，如果你知道的值将永远是否定的。

有些处理器可以处理无符号的整数比有符号整数的运算速度要快。（这也是很好的实践，帮助self-documenting代码）。

4、在一个逻辑条件语句中常数项永远在左侧。

int x = 4; 
  
if ( x = 1 ) { 
  
    x = x + 2; 
  
    printf("%d",x);          // Output is 3 
  
} 
int x = 4; 
  
if ( 1 = x ) { 
  
    x = x + 2; 
  
    printf("%d",x);   // Compilation error 
  
}

使用“=”赋值运算符，替代“==”相等运算符，这是个常见的输入错误。常数项放在左侧，将产生一个编译时错误，让你轻松捕获你的错误。注：“=”是赋值运算符。 b = 1会设置变量b等于值1。 “==”相等运算符。如果左侧等于右侧，返回true，否则返回false。

5、在可能的情况下使用typedef替代macro。当然有时候你无法避免macro，但是typedef更好。

typedef int* INT_PTR; 
  
INT_PTR a , b; 
  
# define INT_PTR int*; 
  
INT_PTR a , b;

在这个宏定义中，a是一个指向整数的指针，而b是只有一个整数声明。使用typedef a和b都是整数的指针。

6、确保声明和定义是静态的，除非您希望从不同的文件中调用该函数。

在同一文件函数对其他函数可见，才称之为静态函数。它限制其他访问内部函数，如果我们希望从外界隐藏该函数。现在我们并不需要为内部函数创建头文件，其他看不到该函数。

静态声明一个函数的优点包括：

A）两个或两个以上具有相同名称的静态函数，可用于在不同的文件。
B）编译消耗减少，因为没有外部符号处理。

让我们做更好的理解，下面的例子：

/*first_file.c*/
  
static int foo ( int a ) 
  
{ 
  
/*Whatever you want to in the function*/
  
} 
  
/*second_file.c*/
  
int foo ( int ) 
  
int main() 
  
{ 
  
    foo();      // This is not a valid function call as the function foo can only be called by any other function within first_file.c where it is defined. 
  
    return 0; 
  
}

7、使用Memoization，以避免递归重复计算

考虑Fibonacci（斐波那契）问题;

Fibonacci问题是可以通过简单的递归方法来解决：

int fib ( n ) 
  
{ 
  
    if ( n == 0 || n == 1 ) { 
  
        return 1; 
  
    } 
  
    else { 
  
        return fib( n - 2 ) + fib ( n - 1 ); 
  
    } 
  
}

注：在这里，我们考虑Fibonacci 系列从1开始，因此，该系列看起来：1，1，2，3，5，8，...

注意：从递归树，我们计算fib（3）函数2次，fib（2）函数3次。这是相同函数的重复计算。如果n非常大，fib

这个简单的技术叫做Memoization，可以被用在递归，加强计算速度。

fibonacci 函数Memoization的代码，应该是下面的这个样子：

int calc_fib ( int n ) 
  
{ 
  
    int val[ n ] , i; 
  
    for ( i = 0; i <=n; i++ ) { 
  
        val[ i ] = -1;      // Value of the first n + 1 terms of the fibonacci terms set to -1 
  
    } 
  
    val[ 0 ] = 1;               // Value of fib ( 0 ) is set to 1 
  
    val[ 1 ] = 1;           // Value of fib ( 1 ) is set to 1 
  
    return fib( n , val ); 
  
} 
  
int fib( int n , int* value ) 
  
{ 
  
    if ( value[ n ] != -1 ) { 
  
        return value[ n ];              // Using memoization 
  
    } 
  
    else { 
  
        value[ n ] = fib( n - 2 , value ) + fib ( n - 1 , value );          // Computing the fibonacci term 
  
    } 
  
    return value[ n ];                // Returning the value 
  
}

这里calc_fib( n )函数被main()调用。

8、避免悬空指针和野指针

一个指针的指向对象已被删除，那么就成了悬空指针。野指针是那些未初始化的指针，需要注意的是野指针不指向任何特定的内存位置。

void dangling_example() 
  
{ 
  
    int *dp = malloc ( sizeof ( int )); 
  
    /*........*/
  
    free( dp );             // dp is now a dangling pointer 
  
    dp = NULL;      // dp is no longer a dangling pointer 
  
} 
  
void wild_example() 
  
{ 
  
    int *ptr;       // Uninitialized pointer 
  
    printf("%u"\n",ptr ); 
  
    printf("%d",*ptr ); 
  
}

当遭遇这些指针，程序通常是”怪异“的表现。

9、永远记住释放你分配给程序的任何内存。上面的例子就是如果释放dp指针（我们使用malloc()函数调用）。

原文：fortystones 译文：oschina

C语言指针5分钟教程

2012/09/24 | 分类：书籍与教程, 程序员 | 2 条评论 | 来源：伯乐在线 | 标签： C语言, 指针

分享到：更多 2

英文原文： Dennis Kubes，编译：伯乐在线 – 唐尤华

指针、引用和取值

什么是指针？什么是内存地址？什么叫做指针的取值？指针是一个存储计算机内存地址的变量。在这份教程里“引用”表示计算机内存地址。从指针指向的内存读取数据称作指针的取值。指针可以指向某些具体类型的变量地址，例如int、long和double。指针也可以是void类型、NULL指针和未初始化指针。本文会对上述所有指针类型进行探讨。

根据出现的位置不同，操作符 * 既可以用来声明一个指针变量，也可以用作指针的取值。当用在声明一个变量时，*表示这里声明了一个指针。其它情况用到*表示指针的取值。

&是地址操作符，用来引用一个内存地址。通过在变量名字前使用&操作符，我们可以得到该变量的内存地址。

// 声明一个int指针 
int *ptr; 
// 声明一个int值 
int val = 1; 
// 为指针分配一个int值的引用 
ptr = &val; 
// 对指针进行取值，打印存储在指针地址中的内容 
int deref = *ptr; 
printf("%d\n", deref);

第2行，我们通过*操作符声明了一个int指针。接着我们声明了一个int变量并赋值为1。然后我们用int变量的地址初始化我们的int指针。接下来对int指针取值，用变量的内存地址初始化int指针。最终，我们打印输出变量值，内容为1。

第6行的&val是一个引用。在val变量声明并初始化内存之后，通过在变量名之前使用地址操作符&我们可以直接引用变量的内存地址。

第8行，我们再一次使用*操作符来对该指针取值，可直接获得指针指向的内存地址中的数据。由于指针声明的类型是int，所以取到的值是指针指向的内存地址存储的int值。

这里可以把指针、引用和值的关系类比为信封、邮箱地址和房子。一个指针就好像是一个信封，我们可以在上面填写邮寄地址。一个引用（地址）就像是一个邮件地址，它是实际的地址。取值就像是地址对应的房子。我们可以把信封上的地址擦掉，写上另外一个我们想要的地址，但这个行为对房子没有任何影响。

void指针、NULL指针和未初始化指针

一个指针可以被声明为void类型，比如void *x。一个指针可以被赋值为NULL。一个指针变量声明之后但没有被赋值，叫做未初始化指针。

int *uninit; // int指针未初始化 
int *nullptr = NULL; // 初始化为NULL 
void *vptr; // void指针未初始化 
int val = 1; 
int *iptr; 
int *castptr; 
  
// void类型可以存储任意类型的指针或引用 
iptr = &val; 
vptr = iptr; 
printf("iptr=%p, vptr=%p\n", iptr, vptr); 
  
// 通过显示转换，我们可以把一个void指针转成 
// int指针并进行取值 
castptr = (int *)vptr; 
printf("*castptr=%d\n", *castptr); 
  
// 打印null和未初始化指针 
printf("uninit=%p, nullptr=%p\n", uninit, nullptr); 
// 不知道你会得到怎样的返回值，会是随机的垃圾地址吗？ 
// printf("*nullptr=%d\n", nullptr); 
// 这里会产生一个段错误 
// printf("*nullptr=%d\n", nullptr);

执行上面的代码，你会得到类似下面对应不同内存地址的输出。

iptr=0x7fff94b89c6c, vptr=0x7fff94b89c6c 
*castptr=1 
uninit=0x7fff94b89d50, nullptr=(nil)

第1行我们声明了一个未初始化int指针。所有的指针在赋值为NULL、一个引用（地址）或者另一个指针之前都是未被初始化的。第2行我们声明了一个NULL指针。第3行声明了一个void指针。第4行到第6行声明了一个int值和几个int指针。

第9行到11行，我们为int指针赋值为一个引用并把int指针赋值为void指针。void指针可以保存各种其它指针类型。大多数时候它们被用来存储数据结构。可以注意到，第11行我们打印了int和void指针的地址。它们现在指向了同样的内存地址。所有的指针都存储了内存地址。它们的类型只在取值时起作用。

第15到16行，我们把void指针转换为int指针castptr。请注意这里需要显示转换。虽然C语言并不要求显示地转换，但这样会增加代码的可读性。接着我们对castptr指针取值，值为1。

第19行非常有意思，在这里打印未初始化指针和NULL指针。值得注意的是，未初始化指针是有内存地址的，而且是一个垃圾地址。不知道这个内存地址指向的值是什么。这就是为什么不要对未初始化指针取值的原因。最好的情况是你取到的是垃圾地址接下来你需要对程序进行调试，最坏的情况则会导致程序崩溃。

NULL指针被初始化为o。NULL是一个特殊的地址，用NULL赋值的指针指向的地址为0而不是随机的地址。只有当你准备使用这个地址时有效。不要对NULL地址取值，否则会产生段错误。

指针和数组

C语言的数组表示一段连续的内存空间，用来存储多个特定类型的对象。与之相反，指针用来存储单个内存地址。数组和指针不是同一种结构因此不可以互相转换。而数组变量指向了数组的第一个元素的内存地址。

一个数组变量是一个常量。即使指针变量指向同样的地址或者一个不同的数组，也不能把指针赋值给数组变量。也不可以将一个数组变量赋值给另一个数组。然而，可以把一个数组变量赋值给指针，这一点似乎让人感到费解。把数组变量赋值给指针时，实际上是把指向数组第一个元素的地址赋给指针。

int myarray[4] = {1,2,3,0}; 
int *ptr = myarray; 
printf("*ptr=%d\n", *ptr); 
  
// 数组变量是常量，不能做下面的赋值 
// myarray = ptr 
// myarray = myarray2 
// myarray = &myarray2[0]

第1行初始化了一个int数组，第2行用数组变量初始化了一个int指针。由于数组变量实际上是第一个元素的地址，因此我们可以把这个地址赋值给指针。这个赋值与*ptr = &myarray[0]效果相同，显示地把数组的第一个元素地址赋值到了ptr引用。这里需要注意的是，这里指针需要和数组的元素类型保持一致，除非指针类型为void。

指针与结构体

就像数组一样，指向结构体的指针存储了结构体第一个元素的内存地址。与数组指针一样，结构体的指针必须声明和结构体类型保持一致，或者声明为void类型。

struct person { 
  int age; 
  char *name; 
}; 
struct person first; 
struct person *ptr; 
  
first.age = 21; 
char *fullname = "full name"; 
first.name = fullname; 
ptr = &first; 
  
printf("age=%d, name=%s\n", first.age, ptr->name);