C 语言基本语法（1）

ゝ一纸荒年。 2023-10-08 14:42 20阅读 0赞

#### 文章目录 ####

*  写在前面
 *  1、基本规则
 *  2、数据类型
 *   *  2.1、基本类型
     *   *  2.1.1、数值前缀
         *  2.1.2、数值后缀
         *  2.1.3、字符和字符串
     *  2.2、枚举类型
 *  3、变量与函数
 *   *  3.1、变量
     *  3.2、函数
     *  3.4、指针
     *   *  3.4.1、变量指针
         *  3.4.2、函数指针
 *  4、程序结构
 *   *  4.1、if
     *  4.2、switch
     *  4.3、三元表达式
     *  4.4、while
     *  4.5、for
     *  4.6、do...while
     *  4.5、跳出和跳转
 *  5、结构体 struct
 *   *  5.1、结构体定义
     *  5.2、结构体调用
     *  5.3、结构体指针
 *  6、公用体 union
 *  7、位域
 *  8、typedef 与 \#define

## 写在前面 ##

## 1、基本规则 ##

<table> 
 <thead> 
  <tr> 
   <th>规则</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>程序的第一行： #include &lt;stdio.h&gt;</td> 
   <td>告诉 C 编译器在实际编译之前要包含 stdio.h 文件</td> 
  </tr> 
  <tr> 
   <td>int main() 是主函数</td> 
   <td>程序从int main() 开始执行</td> 
  </tr> 
  <tr> 
   <td>空格、换行、注释程序不会读取</td> 
   <td>注释：//、/* */、</td> 
  </tr> 
  <tr> 
   <td>每行以 ; 结束</td> 
   <td>分号是语句结束符</td> 
  </tr> 
  <tr> 
   <td>区分大小写</td> 
   <td>C 是区分大小写的编程语言</td> 
  </tr> 
  <tr> 
   <td>变量、方法命名可以以“_”开始</td> 
   <td>一个标识符以字母 A-Z 或 a-z 或下划线 _ 开始，后跟零个或多个字母、下划线和数字（0-9）</td> 
  </tr> 
 </tbody> 
</table>

实例

#include <stdio.h>
     
    int main()
    {
        
       /* 我的第一个 C 程序 */
       printf("Hello, World! \n");
       
       return 0;
    }

## 2、数据类型 ##

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>基本类型</td> 
   <td>char、int、short、long、float、double、long double</td> 
  </tr> 
  <tr> 
   <td>枚举类型</td> 
   <td>enum</td> 
  </tr> 
  <tr> 
   <td>void类型</td> 
   <td>void</td> 
  </tr> 
  <tr> 
   <td>派生类型</td> 
   <td>指针类型、数组类型、结构类型、共用体类型和函数类型</td> 
  </tr> 
 </tbody> 
</table>

> 整数类型前面都可以加一个unsigned，表示该类型的值从0开始，char前面还可以加signed，表示值为-128 到 127。  
> 例：unsigned char a = 1; signed char b = 2;

### 2.1、基本类型 ###

基本类型就是字符型、整型、浮点这三大类

#### 2.1.1、数值前缀 ####

前缀用来表示数字进制

*  无前缀，默认十进制，10，31。
 *  0 ，以0开头为8进制：045，021。
 *  0b，以0b开头为2进制：0b11101101。
 *  0x，以0x开头为16进制：0x21458adf。

#### 2.1.2、数值后缀 ####

后缀用来表示数值类型(大写与小写同义)

*  无后缀，整数默认int、浮点默认double
 *  2.3 为双精度double（15 位有效位）
 *  2.5f 为单精度float（6 位有效位）
 *  11L 为long
 *  11.1L为long double
 *  10ul 为无符号long

#### 2.1.3、字符和字符串 ####

*  字符型，char 类型，用单引号，如char a = ‘m’;char b = 109; char c = ‘\\n’;
 *  字符串，通过字符指针或数组来间接实现，如char \*a=“hello,world”、char b\[\]=“linux”、char site\[7\] = \{‘R’, ‘U’, ‘N’, ‘O’, ‘O’, ‘B’, ‘\\0’\};

> char \*p=“hello,world” 这句代码的本质：指针 p 指向头"h"、尾"d" 的地址相连的一段内存

字符串操作：

#include <stdio.h>
    #include <string.h>
     
    int main ()
    {
        
       char str1[14] = "runoob";
       char str2[14] = "google";
       char str3[14];
       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;
    }

### 2.2、枚举类型 ###

枚举定义：

enum DAY
    {
        
          MON=1, TUE, WED, THU, FRI, SAT, SUN
    };
    enum DAY day;

enum DAY
    {
        
          MON=1, TUE, WED, THU, FRI, SAT, SUN
    } day;

enum
    {
        
          MON=1, TUE, WED, THU, FRI, SAT, SUN
    } day;

枚举的第一个给值默认为0，后面的值依次+1，  
下面是枚举遍历实例：

#include <stdio.h>
     
    enum DAY
    {
        
          MON=1, TUE, WED, THU, FRI, SAT, SUN
    } day;
    
    int main()
    {
        
        // 遍历枚举元素
        for (day = MON; day <= SUN; day++) {
        
            printf("枚举元素：%d \n", day);
        }
    }

如果枚举的值不连续，则无法遍历，如下：

enum
    {
        
        ENUM_0,
        ENUM_10 = 10,
        ENUM_11
    };

## 3、变量与函数 ##

### 3.1、变量 ###

变量定义

// 声明并定义变量, auto有和没有一样
    int a;
    char a = 'l';
    auto int month;
    
    // extern 声明变量
    extern double b;
    extern float b = 1.1f;
    
    // const 常量,声明常量要在一个语句内完成
    const long A = 1L;
    
    // register 存储类用于定义存储在寄存器中,通常是一个字
    register int  a;
    
    // static 修饰全局变量和局部变量的应用，它修饰的变量不会被重置
    static int count=10;
    
    // extern 是用来在另一个文件中声明一个全局变量或函数
    extern int count;

### 3.2、函数 ###

函数定义

int max(int num1, int num2) 
    {
        
       int result = num1 + num2;
       return result; 
    }

函数调用

t1.c

/* 函数定义 */
    void swap(int *x, int *y)
    {
        
       int temp;
       temp = *x;    /* 保存地址 x 的值 */
       *x = *y;      /* 把 y 赋值给 x */
       *y = temp;    /* 把 temp 赋值给 y */
      
       return;
    }

t2.c

#include <stdio.h>
     
    /* 函数声明 */
    void swap(int *x, int *y);
     
    int main ()
    {
        
       /* 局部变量定义 */
       int a = 100;
       int b = 200;
     
       printf("交换前，a 的值： %d\n", a );
       printf("交换前，b 的值： %d\n", b );
     
       /* 调用函数来交换值
        * &a 表示指向 a 的指针，即变量 a 的地址
        * &b 表示指向 b 的指针，即变量 b 的地址
       */
       swap(&a, &b);
     
       printf("交换后，a 的值： %d\n", a );
       printf("交换后，b 的值： %d\n", b );
     
       return 0;
    }

### 3.4、指针 ###

#### 3.4.1、变量指针 ####

每一个变量都有一个内存位置，每一个内存位置都定义了可使用 & 运算符访问的地址

#include <stdio.h>
     
    int main ()
    {
        
        int var_runoob = 10;
        int *p;              // 定义指针变量
        p = &var_runoob;
     
       printf("var_runoob 变量的地址： %p\n", p);
       return 0;
    }

指针\*p前面的类型int，是指针所指向的数据的类型，指针自己的类型都是 “16进制地址值”。  
指针等于NULL时，指向的地址是0x0，也就是空指针。

指针是可以运算的，如下：

#include <stdio.h>
     
    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] = %p\n", i, ptr );
          printf("存储值：var[%d] = %d\n", i, *ptr );
     
          /* 指向下一个位置 */
          ptr++;
       }
       return 0;
    }

执行结果

存储地址：var[0] = e4a298cc
    存储值：var[0] = 10
    存储地址：var[1] = e4a298d0
    存储值：var[1] = 100
    存储地址：var[2] = e4a298d4
    存储值：var[2] = 200

#### 3.4.2、函数指针 ####

通常我们说的指针变量是指向一个整型、字符型或数组等变量，而函数指针是指向函数。  
函数指针可以像一般函数一样，用于调用函数、传递参数。

#include <stdio.h>
     
    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;
    }

回调函数：函数指针作为某个函数的参数,如下例

#include <stdlib.h>  
    #include <stdio.h>
     
    // 回调函数
    void populate_array(int *array, size_t arraySize, int (*getNextValue)(void))
    {
        
        for (size_t i=0; i<arraySize; i++)
            array[i] = getNextValue();
    }
     
    // 获取随机值
    int getNextRandomValue(void)
    {
        
        return rand();
    }
     
    int main(void)
    {
        
        int myarray[10];
        /* getNextRandomValue 不能加括号，否则无法编译，因为加上括号之后相当于传入此参数时传入了 int , 而不是函数指针*/
        populate_array(myarray, 10, getNextRandomValue);
        for(int i = 0; i < 10; i++) {
        
            printf("%d ", myarray[i]);
        }
        printf("\n");
        return 0;
    }

## 4、程序结构 ##

### 4.1、if ###

if(a == 10)
    {
        
       /* 当布尔表达式 1 为真时执行 */
    }
    else if(a == 11)
    {
        
       /* 当布尔表达式 2 为真时执行 */
    }
    else 
    {
        
       /* 当上面条件都不为真时执行 */
    }

### 4.2、switch ###

/* 局部变量定义 */
       char grade = 'B';
     
       switch(grade)
       {
        
       case 'A' :
          printf("很棒！\n" );
          break;
       case 'B' :
       default :
          printf("无效的成绩\n" );
       }

### 4.3、三元表达式 ###

a > 1 ? 0 : 10;

### 4.4、while ###

while( a < 20 )
       {
        
          a++;
       }

### 4.5、for ###

for( int a = 10; a < 20; a++ )
       {
        
          printf("a 的值： %d\n", a);
       }

### 4.6、do…while ###

do
       {
        
           printf("a 的值： %d\n", a);
           a = a + 1;
       }while( a < 20 );

### 4.5、跳出和跳转 ###

break;     // 终止循环或 switch 语句
     continue;  // 跳出本次循环
     goto;      // 跳到某行

LOOP:do
       {
        
          if( a == 15)
          {
        
             /* 跳过迭代 */
             a = a + 1;
             goto LOOP;
          }
          printf("a 的值： %d\n", a);
          a++;
         
       }while( a < 20 );

## 5、结构体 struct ##

### 5.1、结构体定义 ###

定义结构

struct Books
    {
        
       char  title[50];
       char  author[50];
       char  subject[100];
       int   book_id;
    } book;
    
    
    struct 
    {
        
        int a;
        char b;
        double c;
    } s1;
    
    // 定义
    struct SIMPLE
    {
        
        int a;
        char b;
        double c;
    };
    // 声明变量
    struct SIMPLE t1, t2[20], *t3;
    
    
    //也可以用typedef创建新类型
    typedef struct
    {
        
        int a;
        char b;
        double c; 
    } Simple2;
    //现在可以用Simple2作为类型声明新的结构体变量
    Simple2 u1, u2[20], *u3;

结构体里面可以有其他结构体

//此结构体的声明包含了其他的结构体
    struct COMPLEX
    {
        
        char string[100];
        struct SIMPLE a;
    };
     
    //此结构体的声明包含了指向自己类型的指针
    struct NODE
    {
        
        char string[100];
        struct NODE *next_node;
    };

如果两个结构体互相包含，则需要对其中一个结构体进行不完整声明

struct B;    //对结构体B进行不完整声明
     
    //结构体A中包含指向结构体B的指针
    struct A
    {
        
        struct B *partner;
        //other members;
    };
     
    //结构体B中包含指向结构体A的指针，在A声明完后，B也随之进行声明
    struct B
    {
        
        struct A *partner;
        //other members;
    };

### 5.2、结构体调用 ###

结构体变量的初始化、调用实例：

#include <stdio.h>
     
    struct Books
    {
        
       char  title[50];
       char  author[50];
       char  subject[100];
       int   book_id;
    } book = {
        "C 语言", "RUNOOB", "编程语言", 123456};
     
    int main()
    {
        
        printf("title : %s\nauthor: %s\nsubject: %s\nbook_id: %d\n", book.title, book.author, book.subject, book.book_id);
    }

#include <stdio.h>
    #include <string.h>
     
    struct Books
    {
        
       char  title[50];
       char  author[50];
       char  subject[100];
       int   book_id;
    };
     
    int main( )
    {
        
       struct Books Book1;        /* 声明 Book1，类型为 Books */
       struct Books Book2;        /* 声明 Book2，类型为 Books */
     
       /* 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;
    }

结构体也可以作为函数参数

#include <stdio.h>
    #include <string.h>
     
    struct Books
    {
        
       char  title[50];
       char  author[50];
       char  subject[100];
       int   book_id;
    };
     
    /* 函数声明 */
    void printBook( struct Books book );
    int main( )
    {
        
       struct Books Book1;        /* 声明 Book1，类型为 Books */
       struct Books Book2;        /* 声明 Book2，类型为 Books */
     
       /* 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 信息 */
       printBook( Book1 );
     
       /* 输出 Book2 信息 */
       printBook( Book2 );
     
       return 0;
    }
    void printBook( struct Books book )
    {
        
       printf( "Book title : %s\n", book.title);
       printf( "Book author : %s\n", book.author);
       printf( "Book subject : %s\n", book.subject);
       printf( "Book book_id : %d\n", book.book_id);
    }

### 5.3、结构体指针 ###

定义

struct Books *struct_pointer = &Book1;

使用指向该结构的指针访问结构的成员，须使用 -> 运算符，如下

struct_pointer->title;

实例

#include <stdio.h>
    #include <string.h>
     
    struct Books
    {
        
       char  title[50];
       char  author[50];
       char  subject[100];
       int   book_id;
    };
     
    /* 函数声明 */
    void printBook( struct Books *book );
    int main( )
    {
        
       struct Books Book1;        /* 声明 Book1，类型为 Books */
       struct Books Book2;        /* 声明 Book2，类型为 Books */
     
       /* Book1 详述 */
       strcpy( Book1.title, "C语言基础");
       strcpy( Book1.author, "zhangsan"); 
       strcpy( Book1.subject, "编程语言");
       Book1.book_id = 6495407;
     
       /* Book2 详述 */
       strcpy( Book2.title, "C语言进阶");
       strcpy( Book2.author, "lisi");
       strcpy( Book2.subject, "编程语言");
       Book2.book_id = 6495700;
     
       /* 通过传 Book1 的地址来输出 Book1 信息 */
       printBook( &Book1 );
     
       /* 通过传 Book2 的地址来输出 Book2 信息 */
       printBook( &Book2 );
     
       return 0;
    }
    void printBook( struct Books *book )
    {
        
       printf( "书籍标题: %s\n", book->title);
       printf( "书籍作者: %s\n", book->author);
       printf( "书籍分类: %s\n", book->subject);
       printf( "书籍ID: %d\n", book->book_id);
    }

## 6、公用体 union ##

一个公用体，可以赋值多种类型，但有其中一个类型正在使用，如下

#include <stdio.h>
    #include <string.h>
     
    union Data
    {
        
       int i;
       float f;
       char  str[20];
    };
     
    int main( )
    {
        
       union Data data;        
     
       // 只有i在使用
       data.i = 10;
       printf( "data.i : %d\n", data.i);
       
       // 只有f在使用
       data.f = 220.5;
       printf( "data.f : %f\n", data.f);
       
       // 只有str在使用
       strcpy( data.str, "C Programming");
       printf( "data.str : %s\n", data.str);
     
       return 0;
    }

## 7、位域 ##

位域在结构体中使用，用来限制一个数值的长度（转为二进制后的长度），如下例：

struct k{
        
        int a:1;
        int  :2;    /* 位域可以是无名位域，这时它只用来作填充或调整位置。无名的位域是不能使用的。 */
        int b:3;
        int c:2;
    };

`int a:1;`表示该位域只能为0、1 （二进制）  
`int c:2;`表示该位域只能为00、01、10、11 （二进制）

位域类型只能是：int(整型)，unsigned int(无符号整型)，signed int(有符号整型) 三种类型。  
使用实例：

int main(){
        
        struct bs{
        
            unsigned a:1;
            unsigned b:3;
            unsigned c:4;
        } bit,*pbit;
        bit.a=1;    /* 给位域赋值（应注意赋值不能超过该位域的允许范围） */
        bit.b=7;    /* 给位域赋值（应注意赋值不能超过该位域的允许范围） */
        bit.c=15;    /* 给位域赋值（应注意赋值不能超过该位域的允许范围） */
        printf("%d,%d,%d\n",bit.a,bit.b,bit.c);    /* 以整型量格式输出三个域的内容 */
        pbit=&bit;    /* 把位域变量 bit 的地址送给指针变量 pbit */
        pbit->a=0;    /* 用指针方式给位域 a 重新赋值，赋为 0 */
        pbit->b&=3;    /* 使用了复合的位运算符 "&="，相当于：pbit->b=pbit->b&3，位域 b 中原有值为 7，与 3 作按位与运算的结果为 3（111&011=011，十进制值为 3） */
        pbit->c|=1;    /* 使用了复合位运算符"|="，相当于：pbit->c=pbit->c|1，其结果为 15 */
        printf("%d,%d,%d\n",pbit->a,pbit->b,pbit->c);    /* 用指针方式输出了这三个域的值 */
    }

## 8、typedef 与 \#define ##

*  typedef 仅限于为类型定义符号名称，\#define 不仅可以为类型定义别名，也能为数值定义别名，比如您可以定义 1 为 ONE。
 *  typedef 是由编译器执行解释的，\#define 语句是由预编译器进行处理的。

typedef 实例

#include <stdio.h>
    #include <string.h>
     
    typedef struct Books
    {
        
       char  title[50];
       char  author[50];
       char  subject[100];
       int   book_id;
    } Book;
     
    int main( )
    {
        
       Book book;
     
       strcpy( book.title, "C 教程");
       strcpy( book.author, "BeanInJ"); 
       strcpy( book.subject, "编程语言");
       book.book_id = 12345;
     
       printf( "书标题 : %s\n", book.title);
       printf( "书作者 : %s\n", book.author);
       printf( "书类目 : %s\n", book.subject);
       printf( "书 ID : %d\n", book.book_id);
     
       return 0;
    }

\#define实例

#include <stdio.h>
     
    #define TRUE  1
    #define FALSE 0
     
    int main( )
    {
        
       printf( "TRUE 的值: %d\n", TRUE);
       printf( "FALSE 的值: %d\n", FALSE);
     
       return 0;
    }