C C语言中关键词，以及知识点复习

C语言学习

C语言练习知识点

auto        局部变量（自动储存）

break       无条件退出程序最内层循环

case        switch语句中选择项

char        单字节整型

const       定义不可更改值的变量

continue    中断本次循环，并转向下一次循环

default     switch语句中的默认选择项

do          用于构成do.....while循环语句

double      双精度浮点型

else        构成if.....else选择程序结构

enum        枚举

extern      声明外部全局变量

float       单精度浮点型

for         构成for循环语句

goto        跳到程序中指定的标签位置

if          构成if....else选择结构

int         整型

long        长整型

register    定义CPU内部寄存的变量

return      用于返回函数的返回值

short       短整型

signed      有符号数 与基本整型类型结合使用

sizeof      计算表达式或数据类型的占用字节数

static      定义静态变量、函数

struct      定义结构类型

switch      构成switch选择结构

typedef     重新定义数据类型

union       联合类型

unsigned    定义无符号数据 与基本整型类型结合使用

void        定义任意类型指针void * , 无参数 , 无返回值等

volatile    易失性变量

while       用于构成do...while或while循环结构

 

C 头文件的使用 

#include "heard.h"

void heard1(int r){

    printf("%d\n",r);

}

#ifndef heard_h
#define heard_h

#include <stdio.h>
void heard1(int r);
#endif /* heard_h */

／／／／／／／／／／／／／／／／／／／／／／／／／

#include <stdio.h>
#include "heee.h"
#include "heard.h"
int main(int argc, const char * argv[]) {

    heard1();

    int ee = hee1();

    printf("\n%d",ee);

       return ;
}

头文件调用

 C 结构体 共同体 位域

//共用体：共用体是一种特殊的数据类型，允许您在相同的内存位置存储不同的数据类型。您可以定义一个带有多成员的共用体，但是任何时候只能有一个成员带有值。共用体提供了一种使用相同的内存位置的有效方式。
union Data
{
    int i;
    float f;
    char str[];

};
//，同一时间只能使用一个共用体，使用多个最后一个使用的无误之前的会错乱；
 union Data date;//声明
    date.i = ;
    date.f = 22.22;
     strcpy(date.str,"woshiyige");
print(“%d—%f—%s”,date.i,date.f,date.str);

//结构体：相当于OC中的类，Swift中的类也是一个结构体（暂时这么理解）

#include <stdio.h>

struct Books
{

    char title[];
    char author[];
    char subject[];
    int bookid;

};

void printBook(struct Books book);//函数声明

int main(int argc, const char * argv[]) {

    //声明
    struct Books book1;
    struct Books book2;
    strcpy(book1.title,"zhonghua");
    strcpy(book1.author, "xude");
    book1.bookid = ;

    strcpy(book2.title,"zhongguo");
    strcpy(book2.author, "nide");
    book2.bookid = ;

    printBook(book1);

       return ;
}

void printBook(struct Books book){

    printf("book.title %s\n",book.title);

    printf("book.authoe %s\n",book.author);

    printf("book.bookid %d\n",book.bookid);

}

//位域：可以 定义类型的储存大小，节省不必要的内存开销
//类型说明符 位域名: 位域长度
struct wei{

    int kai:;
    int guan:;
    unsigned a:;
    unsigned :; //空域 从下一个单元 开始存放

};
void printBook(struct Books book);//函数声明

int main(int argc, const char * argv[]) {

    //声明位域
    struct wei w;
    w.a = ;
    w.guan = ;//⚠️注意不要超过位域的大小

    }

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

int main(int argc, const char * argv[]) {

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

    //#define 是 C 指令，用于为各种数据类型定义别名，与 typedef 类似，但是它们有以下几点不同：
    typedef 仅限于为类型定义符号名称，#define 不仅可以为类型定义别名，也能为数值定义别名，比如您可以定义 1 为 ONE。
    typedef 是由编译器执行解释的，#define 语句是由预编译器进行处理的。
       return ;
}

C 中文件的读写

C
//读写文件 txt,本地化数据
#include <stdio.h>

int main(int argc, const char * argv[]) {

    //文件的读取
    /*打开文件
     您可以使用 fopen( ) 函数来创建一个新的文件或者打开一个已有的文件，这个调用会初始化类型 FILE 的一个对象，类型 FILE 包含了所有用来控制流的必要的信息。下面是这个函数调用的原型：
     FILE *fopen( const char * filename, const char * mode );
     在这里，filename 是字符串，用来命名文件，访问模式 mode 的值可以是下列值中的一个：
     模式    描述
     r    打开一个已有的文本文件，允许读取文件。
     w    打开一个文本文件，允许写入文件。如果文件不存在，则会创建一个新文件。在这里，您的程序会从文件的开头写入内容。
     a    打开一个文本文件，以追加模式写入文件。如果文件不存在，则会创建一个新文件。在这里，您的程序会在已有的文件内容中追加内容。
     r+    打开一个文本文件，允许读写文件。
     w+    打开一个文本文件，允许读写文件。如果文件已存在，则文件会被截断为零长度，如果文件不存在，则会创建一个新文件。
     a+    打开一个文本文件，允许读写文件。如果文件不存在，则会创建一个新文件。读取会从文件的开头开始，写入则只能是追加模式。
     如果处理的是二进制文件，则需使用下面的访问模式来取代上面的访问模式：
     "rb", "wb", "ab", "rb+", "r+b", "wb+", "w+b", "ab+", "a+b"
     关闭文件
     ；
     为了关闭文件，请使用 fclose( ) 函数。函数的原型如下：
     int fclose( FILE *fp );*/

//lizi

    FILE * fp;
    fp = fopen("/tmp/text.txt", "w+");//在tmp目录下创建text.txt  文件类型为w+

    fprintf(fp, "This is testing for fprintff....\n");
    fputs("123456\n", fp);//以上是两种不同的写入方法

    fclose(fp);//关闭文件

    FILE * pp;
    pp = fopen("/tmp/tt.txt", "a+");
    fprintf(pp, "woshiyigetianjiade");
    fputs("woshidierge", pp);

    fclose(pp);

    FILE * yy;
    yy = fopen("uu.txt", "w");
    fprintf(yy, "yyyyyyyyyyyy");
    fputs("ffffffffff", yy);

    fclose(yy);

    //文件等读取
    //如果这个函数在读取最后一个字符之前就遇到一个换行符 '\n' 或文件的末尾 EOF，则只会返回读取到的字符，包括换行符。您也可以使用 int fscanf(FILE *fp, const char *format, ...) 函数来从文件中读取字符串，但是在遇到第一个空格字符时，它会停止读取

    FILE * gg;  //定义文件
    char  butff[];//char大小
   gg = fopen("/tmp/text.txt", "r"); //获取文件

    fscanf(gg, "%s",butff);
    printf("1:%s\n",butff); // fscanf 输出 遇到空格会停止 读取

    fgets(butff, , gg);
    printf("2: %s",butff);

    fgets(butff, , gg); //进行文件读取一整行 遇到\n会停止
    printf("3: %s\n",butff);

    /*输出
     1:This
     2:  is testing for fprintff....
     3: 123456
*/
    fclose(gg);//关闭文件

       return ;
}

C中 的预处理

//预处理
#include <stdio.h>

#define shuchu(a) printf(#a)
#define liashuchu(a,b) printf(#a"haiyou"#b"zifudandu")

void wenjian();
void yuchuli();
int main(int argc, const char * argv[]) {

    yuchuli();
    //wenjian();

       return ;
}

void yuchuli(){

    /*
     所有的预处理器命令都是以井号（#）开头。它必须是第一个非空字符，为了增强可读性，预处理器指令应从第一列开始。下面列出了所有重要的预处理器指令：
     指令    描述
     #define    定义宏
     #include    包含一个源代码文件
     #undef    取消已定义的宏
     #ifdef    如果宏已经定义，则返回真
     #ifndef    如果宏没有定义，则返回真
     #if    如果给定条件为真，则编译下面代码
     #else    #if 的替代方案
     #elif    如果前面的 #if 给定条件不为真，当前条件为真，则编译下面代码
     #endif    结束一个 #if……#else 条件编译块
     #error    当遇到标准错误时，输出错误消息
     #pragma    使用标准化方法，向编译器发布特殊的命令到编译器中

     预定义宏
     ANSI C 定义了许多宏。在编程中您可以使用这些宏，但是不同直接修改这些预定义的宏。
     宏    描述
     __DATE__    当前日期，一个以 "MMM DD YYYY" 格式表示的字符常量。
     __TIME__    当前时间，一个以 "HH:MM:SS" 格式表示的字符常量。
     __FILE__    这会包含当前文件名，一个字符串常量。
     __LINE__    这会包含当前行号，一个十进制常量。
     __STDC__    当编译器以 ANSI 标准编译时，则定义为 1。
     */

    /*

     预处理器运算符
     C 预处理器提供了下列的运算符来帮助您创建宏：
     宏延续运算符（\）
     一个宏通常写在一个单行上。但是如果宏太长，一个单行容纳不下，则使用宏延续运算符（\）。例如：
     #define  message_for(a, b)  \
     printf(#a " and " #b ": We love you!\n")
     字符串常量化运算符（#）
     在宏定义中，当需要把一个宏的参数转换为字符串常量时，则使用字符串常量化运算符（#）。在宏中使用的该运算符有一个特定的参数或参数列表。例如：
     #include <stdio.h>

     #define  message_for(a, b)  \
     printf(#a " and " #b ": We love you!\n")

     int main(void)
     {
     message_for(Carole, Debra);
     return 0;
     }
     当上面的代码被编译和执行时，它会产生下列结果：
     Carole and Debra: We love you!*/
    shuchu();

    liashuchu(jdfsjdf, dsadfd);

    printf("日期 %s\n",__DATE__);
    printf("时间 %s\n",__TIME__);

    printf("文件名: %s\n",__FILE__);
    printf("行号:%d\n",__LINE__);
    printf("ANSI : %d\n",__STDC__);

    /*
     日期 Jun 16 2017
     时间 14:28:32
     文件名: /Users/yurong/Documents/代码/C/C练习/C练习/main.c
     行号:55
     ANSI : 1
     */

}

C中的递归

#include <stdio.h>

double faction(unsigned int i);

int main(int argc, const char * argv[]) {

    //递归 C 语言支持递归，即一个函数可以调用其自身。但在使用递归时，程序员需要注意定义一个从函数退出的条件，否则会进入死循环。\
    与直接的语句(如while循环)相比，递归函数会耗费更多的运行时间，并且要占用大量的栈空间。递归函数每次调用自身时，都需要把它的状态存到栈中，以便在它调用完自身后，程序可以返回到它原来的状态。未经精心设计的递归函数总是会带来麻烦。
    //下面的实例使用递归函数计算一个给定的数的阶乘：
    int i = ;

    printf("%d 的阶乘 = %f\n",i,faction(i));

       return ;
}

double faction(unsigned int i){

    if (i<=) {
        return ;
    }

    return i* faction(i-);

}