c语言结语,C语言总结

C语言小结，适用于有其他编程语言基础的开发者

#include

int main() {

/* 我的第一个 C 程序 */

printf("Hello, World! \n");

return 0;

}

● 所有的 C 语言程序都需要包含 main() 函数。 代码从 main() 函数开始执行。

● /* … */ 用于注释说明。

● printf() 用于格式化输出到屏幕。printf() 函数在 “stdio.h” 头文件中声明。

● stdio.h 是一个头文件 (标准输入输出头文件) and #include 是一个预处理命令，用来引入头文件。 当编译器遇到 printf() 函数时，如果没有找到 stdio.h 头文件，会发生编译错误。

● return 0; 语句用于表示退出程序。

常量

在 C 中，有两种简单的定义常量的方式：

1. 使用 #define 预处理器。

2. 使用 const 关键字。

#define 预处理器

下面是使用 #define 预处理器定义常量的形式：

define identifier value

eg: #define LENGTH 10

const 关键字

您可以使用 const 前缀声明指定类型的常量，如下所示：

const type variable = value;

eg: const int LENGTH = 10;

变量

/* 变量定义 */

int a, b;

/* 初始化 */

a = 10;

b = 20;

函数

#include

/* 函数声明 */

int max(int num1, int num2);

int main ()

{

/* 局部变量定义 */

int a = 100;

int b = 200;

int ret;

/* 调用函数来获取最大值 */

ret = max(a, b);

printf( "Max value is : %d\n", ret );

return 0;

}

/* 函数返回两个数中较大的那个数 */

int max(int num1, int num2)

{

/* 局部变量声明 */

int result;

if (num1 > num2)

result = num1;

else

result = num2;

return result;

}

把 max() 函数和 main() 函数放一块，编译源代码。当运行最后的可执行文件时，会产生下列结果：

Max value is : 200

数组

初始化

double balance[] = {1000.0, 2.0, 3.4, 7.0, 50.0};

取值

double value=balance[2]

指针

每一个内存位置都定义了可使用连字号(&)运算符访问的地址，它表示了在内存中的一个地址。请看下面的实例，它将输出定义的变量地址：

#include

int main ()

{

int var1;

char var2[10];

printf("var1 变量的地址： %x\n", &var1 );

printf("var2 变量的地址： %x\n", &var2 );

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

var1 变量的地址： bff5a400

var2 变量的地址： bff5a3f6

星号是用来指定一个变量是指针。以下是有效的指针声明：

int *ip; /* 一个整型的指针 */

double *dp; /* 一个 double 型的指针 */

float *fp; /* 一个浮点型的指针 */

char *ch /* 一个字符型的指针 */

指针的使用

#include

int main ()

{

int var = 20; /* 实际变量的声明 */

int *ip; /* 指针变量的声明 */

ip = &var; /* 在指针变量中存储 var 的地址 */

printf("Address of var variable: %x\n", &var );

/* 在指针变量中存储的地址 */

printf("Address stored in ip variable: %x\n", ip );

/* 使用指针访问值 */

printf("Value of *ip variable: %d\n", *ip );

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

Address of var variable: bffd8b3c

Address stored in ip variable: bffd8b3c

Value of *ip variable: 20

指针的算术运算

假设 ptr 是一个指向地址 1000 的整型指针，是一个 32 位的整数，让我们对该指针执行下列的算术运算：

ptr++

在执行完上述的运算之后，ptr 将指向位置 1004，因为 ptr 每增加一次，它都将指向下一个整数位置，即当前位置往后移 4 个字节。这个运算会在不影响内存位置中实际值的情况下，移动指针到下一个内存位置。如果 ptr 指向一个地址为 1000 的字符，上面的运算会导致指针指向位置 1001，因为下一个字符位置是在 1001。

递增一个指针

我们喜欢在程序中使用指针代替数组，因为变量指针可以递增，而数组不能递增，因为数组是一个常量指针。下面的程序递增变量指针，以便顺序访问数组中的每一个元素：

#include

const int MAX = 3;

int main ()

{

int var[] = {10, 100, 200};

int i, *ptr;

/* 指针中的数组地址 */

ptr = var;

for ( i = 0; i < MAX; i++)

{

printf("存储地址：var[%d] = %x\n", i, ptr );

printf("存储值：var[%d] = %d\n", i, *ptr );

/* 移动到下一个位置 */

ptr++;

}

return 0;

}

//当上面的代码被编译和执行时，它会产生下列结果：

//存储地址：var[0] = bf882b30

//存储值：var[0] = 10

//存储地址：of var[1] = bf882b34

//存储值： var[1] = 100

//存储地址：of var[2] = bf882b38

//存储值：var[2] = 200

对于int ptr;

ptr存在是地址，ptr存的是此地址的值

函数指针

函数指针是指向函数。

以下实例声明了函数指针变量 p，指向函数 max：

实例

#include

int max(int x, int y)

{

return x > y ? x : y;

}

int main(void)

{

/* p 是函数指针 */

int (* p)(int, int) = & max; // &可以省略

int a, b, c, d;

printf("请输入三个数字:");

scanf("%d %d %d", & a, & b, & c);

/* 与直接调用函数等价，d = max(max(a, b), c) */

d = p(p(a, b), c);

printf("最大的数字是: %d\n", d);

return 0;

}

编译执行，输出结果如下：

请输入三个数字:1 2 3

最大的数字是: 3

字符串

C 中有大量操作字符串的函数：

1 strcpy(s1, s2);

复制字符串 s2 到字符串 s1。

2 strcat(s1, s2);

连接字符串 s2 到字符串 s1 的末尾。

3 strlen(s1);

返回字符串 s1 的长度。

4 strcmp(s1, s2);

如果 s1 和 s2 是相同的，则返回 0；如果 s1s2 则返回大于 0。

5 strchr(s1, ch);

返回一个指针，指向字符串 s1 中字符 ch 的第一次出现的位置。

6 strstr(s1, s2);

返回一个指针，指向字符串 s1 中字符串 s2 的第一次出现的位置。

下面的实例使用了上述的一些函数：

#include

#include

int main ()

{

char str1[12] = "Hello";

char str2[12] = "World";

char str3[12];

int len ;

/* 复制 str1 到 str3 */

strcpy(str3, str1);

printf("strcpy( str3, str1) : %s\n", str3 );

/* 连接 str1 和 str2 */

strcat( str1, str2);

printf("strcat( str1, str2): %s\n", str1 );

/* 连接后，str1 的总长度 */

len = strlen(str1);

printf("strlen(str1) : %d\n", len );

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

strcpy( str3, str1) : Hello

strcat( str1, str2): HelloWorld

strlen(str1) : 10

结构体

下面是声明 Book 结构的方式：

struct Books

{

char title[50];

char author[50];

char subject[100];

int book_id;

} book;

访问结构成员

为了访问结构的成员，我们使用成员访问运算符(.)。成员访问运算符是结构变量名称和我们要访问的结构成员之间的一个句号。您可以使用 struct 关键字来定义结构类型的变量。下面的实例演示了结构的用法：

#include

#include

struct Books

{

char title[50];

char author[50];

char subject[100];

int book_id;

};

int main( )

{

struct Books Book1; /* 声明 Book1，类型为 Book */

struct Books Book2; /* 声明 Book2，类型为 Book */

/* Book1 详述 */

strcpy( Book1.title, "C Programming");

strcpy( Book1.author, "Nuha Ali");

strcpy( Book1.subject, "C Programming Tutorial");

Book1.book_id = 6495407;

/* Book2 详述 */

strcpy( Book2.title, "Telecom Billing");

strcpy( Book2.author, "Zara Ali");

strcpy( Book2.subject, "Telecom Billing Tutorial");

Book2.book_id = 6495700;

/* 输出 Book1 信息 */

printf( "Book 1 title : %s\n", Book1.title);

printf( "Book 1 author : %s\n", Book1.author);

printf( "Book 1 subject : %s\n", Book1.subject);

printf( "Book 1 book_id : %d\n", Book1.book_id);

/* 输出 Book2 信息 */

printf( "Book 2 title : %s\n", Book2.title);

printf( "Book 2 author : %s\n", Book2.author);

printf( "Book 2 subject : %s\n", Book2.subject);

printf( "Book 2 book_id : %d\n", Book2.book_id);

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

Book 1 title : C Programming

Book 1 author : Nuha Ali

Book 1 subject : C Programming Tutorial

Book 1 book_id : 6495407

Book 2 title : Telecom Billing

Book 2 author : Zara Ali

Book 2 subject : Telecom Billing Tutorial

Book 2 book_id : 6495700

共用体

下面定义一个名为 Data 的共用体类型，有三个成员 i、f 和 str：

union Data

{

int i;

float f;

char str[20];

} data;

现在，Data 类型的变量可以存储一个整数、一个浮点数，或者一个字符串。这意味着一个变量(相同的内存位置)可以存储多个多种类型的数据。您可以根据需要在一个共用体内使用任何内置的或者用户自定义的数据类型。

共用体占用的内存应足够存储共用体中最大的成员。例如，在上面的实例中，Data 将占用 20 个字节的内存空间，因为在各个成员中，字符串所占用的空间是最大的。下面的实例将显示上面的共用体占用的总内存大小：

#include

#include

union Data

{

int i;

float f;

char str[20];

};

int main( )

{

union Data data;

printf( "Memory size occupied by data : %d\n", sizeof(data));

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

Memory size occupied by data : 20

C中不管是结构体还是公用体，都类似是Java中的对象

typedef vs #define

#define 是 C 指令，用于为各种数据类型定义别名，与 typedef 类似，但是它们有以下几点不同：

typedef 仅限于为类型定义符号名称，#define 不仅可以为类型定义别名，也能为数值定义别名，比如您可以定义 1 为 ONE。

typedef 是由编译器执行解释的，#define 语句是由预编译器进行处理的。

#include

#define TRUE 1

#define FALSE 0

int main( )

{

printf( "TRUE 的值: %d\n", TRUE);

printf( "FALSE 的值: %d\n", FALSE);

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

TRUE 的值: 1

FALSE 的值: 0

C 语言提供了 typedef 关键字，您可以使用它来为类型取一个新的名字。下面的实例为单字节数字定义了一个术语 BYTE：

typedef unsigned char BYTE;

在这个类型定义之后，标识符 BYTE 可作为类型 unsigned char 的缩写，例如：

BYTE b1, b2;

预处理器

所有的预处理器命令都是以井号(#)开头。它必须是第一个非空字符，为了增强可读性，预处理器指令应从第一列开始。下面列出了所有重要的预处理器指令：

指令 描述

#define 定义宏

#include 包含一个源代码文件

#undef 取消已定义的宏

#ifdef 如果宏已经定义，则返回真

#ifndef 如果宏没有定义，则返回真

#if 如果给定条件为真，则编译下面代码

#else #if 的替代方案

#elif 如果前面的 #if 给定条件不为真，当前条件为真，则编译下面代码

#endif 结束一个 #if……#else 条件编译块

#error 当遇到标准错误时，输出错误消息

#pragma 使用标准化方法，向编译器发布特殊的命令到编译器中

预处理器实例

分析下面的实例来理解不同的指令。

#define MAX_ARRAY_LENGTH 20

这个指令告诉 CPP 把所有的 MAX_ARRAY_LENGTH 替换为 20。使用 #define 定义常量来增强可读性。

#include

#include "myheader.h"

这些指令告诉 CPP 从系统库中获取 stdio.h，并添加文本到当前的源文件中。下一行告诉 CPP 从本地目录中获取 myheader.h，并添加内容到当前的源文件中。

#undef FILE_SIZE

#define FILE_SIZE 42

这个指令告诉 CPP 取消已定义的 FILE_SIZE，并定义它为 42。

#ifndef MESSAGE

#define MESSAGE "You wish!"

#endif

这个指令告诉 CPP 只有当 MESSAGE 未定义时，才定义 MESSAGE。

#ifdef DEBUG

/* Your debugging statements here */

#endif

这个指令告诉 CPP 如果定义了 DEBUG，则执行处理语句。在编译时，如果您向 gcc 编译器传递了 -DDEBUG 开关量，这个指令就非常有用。它定义了 DEBUG，您可以在编译期间随时开启或关闭调试。

预定义宏

ANSI C 定义了许多宏。在编程中您可以使用这些宏，但是不同直接修改这些预定义的宏。

__DATE__ 当前日期，一个以 "MMM DD YYYY" 格式表示的字符常量。

__TIME__ 当前时间，一个以 "HH:MM:SS" 格式表示的字符常量。

__FILE__ 这会包含当前文件名，一个字符串常量。

__LINE__ 这会包含当前行号，一个十进制常量。

__STDC__ 当编译器以 ANSI 标准编译时，则定义为 1。

让我们来尝试下面的实例：

#include

main()

{

printf("File :%s\n", __FILE__ );

printf("Date :%s\n", __DATE__ );

printf("Time :%s\n", __TIME__ );

printf("Line :%d\n", __LINE__ );

printf("ANSI :%d\n", __STDC__ );

}

当上面的代码(在文件 test.c 中)被编译和执行时，它会产生下列结果：

File :test.c

Date :Jun 2 2012

Time :03:36:24

Line :8

ANSI :1

引用头文件的语法

使用预处理指令 #include 可以引用用户和系统头文件。它的形式有以下两种：

#include

这种形式用于引用系统头文件。它在系统目录的标准列表中搜索名为 file 的文件。在编译源代码时，您可以通过 -I 选项把目录前置在该列表前。

#include "file"

这种形式用于引用用户头文件。它在包含当前文件的目录中搜索名为 file 的文件。在编译源代码时，您可以通过 -I 选项把目录前置在该列表前。

内存管理

1 void *calloc(int num, int size);

该函数分配一个带有 num 个元素的数组，每个元素的大小为 size 字节。

2 void free(void *address);

该函数释放 address 所指向的h内存块。

3 void *malloc(int num);

该函数分配一个 num 字节的数组，并把它们进行初始化。

4 void *realloc(void *address, int newsize);

该函数重新分配内存，把内存扩展到 newsize。

当程序退出时，操作系统会自动释放所有分配给程序的内存，但是，建议您在不需要内存时，都应该调用函数 free() 来释放内存。

或者，您可以通过调用函数 realloc() 来增加或减少已分配的内存块的大小。让我们使用 realloc() 和 free() 函数，再次查看上面的实例：

#include

#include

#include

int main()

{

char name[100];

char *description;

strcpy(name, "Zara Ali");

/* 动态分配内存 */

description = malloc( 30 * sizeof(char) );

if( description == NULL )

{

fprintf(stderr, "Error - unable to allocate required memory\n");

}

else

{

strcpy( description, "Zara ali a DPS student.");

}

/* 假设您想要存储更大的描述信息 */

description = realloc( description, 100 * sizeof(char) );

if( description == NULL )

{

fprintf(stderr, "Error - unable to allocate required memory\n");

}

else

{

strcat( description, "She is in class 10th");

}

printf("Name = %s\n", name );

printf("Description: %s\n", description );

/* 使用 free() 函数释放内存 */

free(description);

}

当上面的代码被编译和执行时，它会产生下列结果：

Name = Zara Ali

Description: Zara ali a DPS student.She is in class 10th