[基础]《C Primer》笔记（下篇）

ch = getc(fp);

int ch;           // 用int类型的变量EOF
FILE * fp;
fp = fopen("wacky.txt", "r");
ch = getc(fp);    // 获取初始输入
while (ch != EOF)
{
    putchar(ch);  // 处理输入
    ch = getc(fp);// 获取下一个输入
}

// 简化一下
int ch;
FILE * fp;
fp = fopen("wacky.txt", "r");
while ((ch = getc(fp) != EOF)
{
    putchar(ch);  // 处理输入
}

if (fclose(fp) != 0)
    printf("Error in closeing file %s\n", argv[1]);

fprintf(stdout, "%s\n", "Succ");
while (fscanf(fp, "%s", words) == 1)
rewind(fp);  /* 返回到文件开始处 */

fgets(buf, STLEN, fp);

fputs(buf, fp);

/* reverse.c -- 倒序显示文件中的内容 */
#include <stdio.h>
#include <stdlib.h>
#define CNTL_Z '\032'   /* DOS文本文件中的文件结尾标记 */
#define SLEN 81
int main(void)
{
    char file[SLEN];
    char ch;
    FILE *fp;
    long count, last;
    
    puts("Enter the name of the file to be processed:");
    scanf("%80s", file);
    if ((fp = fopen(file, "rb")) == NULL)
    {
        printf("reverse can't open %s\n", file);
        exit(EXIR_FAILURE)
    }
    
    fseek(fp, 0L, SEEK_END);      /* 定位到文件末尾 */
    last = ftell(fp);
    for (count = 1L; cout <= last; count++)
    {
        fseek(fp, -count, SEEK_END); /* 回退 */
        ch = getc(fp);
        if (ch != CNTL_Z && ch != '\r') /* MS-DOS文件 */
            putchar(ch);
    }
    putchar('\n')；
    fclose(fp);
    return 0;
}

int setvbuf(FILE * restric fp, char * restrict buf, int mode, size_t size);

struct book{
    char title[MAXTITL];
    char author[MAXAUTL];
    float value;
};

struct book library = {
    "The Pious Pirate and the Devious Damsel",
    "Renee Vivotte",
    1.95
}

library.value

struct book surprise = { .value = 10.99 };

struct book library[MAXBKS];

library[2].value

struct guy * him;
him = &barney;

o_data = n_data; // 把一个结构赋值给另一个结构

#define LEN 20
struct names {
    char first[LEN];
    char last[LEN];
};

struct pnames {
  char * first;
  char * last;
};

// 有风险的代码
struct names accountant;
struct pnames attorney;
puts("Enter the last name of your accountant:");
scanf("%s", accountant.last);
puts("Enter the last name of your attorney:");
scanf("%s", attorney.last); /* 潜在危险 */

struct namect{
    char * fname; //用指针替代数组
    char * lname; //
    int letters;
}

void  getinfo (struct namect * pst)
{
    char temp[SLEN];
    printf("Please enter your first name.\n");
    s_gets(temp, SLEN);
    // 分配内存储存名
    pst->fname = (char *) malloc(strlen(temp) + 1);
    // 把名字拷贝到已分配的内存
    strcpy(pst->fname, temp);
    printf("Please enter your last name.\n");
    s_gets(temp, SLEN);
    pst->lname = (char *)malloc(strlen(temp) + 1);
    strcpy(pst->lname, temp);
}

(struct book)("The Idiot", "Fyodor Dostoyevsky", 6.99)

struct flex
{
    int count;
    double average;
    double scores[]; //伸缩型数组成员
}

struct flex * pf;
// 请求为这一个结构和一个数组分配存储空间
pf = malloc(sizeof(struct flex) + 5 * sizeof(double));

// 访问成员
pf->count = 5;
pf->scores[2] = 18.5;

struct flex * pf1, *pf2; 
...
*pf2 = *pf1; // 不要这样做

struct person
{
    int id;
    struct(char first[20]; char last[20];); // 匿名结构
}

/* funds4.c -- 把结构数组传递给函数 */
#include <stdio.h>
#define FUNDLEN 50
#define N 2

struct funds {
    char bank[FUNDLEN];
    double bankfund;
    char save[FUNDLEN];
    double savefund;
};

double sum(const struct funds money[], int n);

int main(void)
{
    struct funds jones[N] = {
        {
          "Garlic-Melon Bank",
          4032.27,
          "Lucky's Savings and Loan",
          8543.94
        },
        {
            "Honest Jack's Bank",
            3620.88,
            "Party Time Savinds",
            3802.91
        }
    };
    
    printf("The Joneses have a total of $.2f.\n"), sum(jones, N);
    
    return 0;
}

double sum(const struct funds money[], int)
{
    double total;
    int i;
    
    for (i=0, total=0; i<n; i++)
        total += money[i]. bankfund + money[i].savefund;
    return (total);
}

#define MAXTITL 40
#define MAXAUTL 40
struct book{
    char title[MAXTITL];
    char author[MAXAUTL];
    float value;
};

fprintf(pbooks, "%s %s %.2f\n", primer.title, primer.author, primer.value);

// 定位到primer结构变量开始的位置，并把结构中所有字节都拷贝到和pbooks相关的文件中
fwrite(&primer, sizeof(struct book), 1, pbooks);
// fread()函数从文件中拷贝一块结构大小的数据到&primer指向的位置

union hold {
    int digit;
    double bigf1;
    char letter;
};

enum spectrum {red, orange, yellow, green, blue, violet};
enum spectrum color;

int c;
color = blue;
if (color == yellow)
    ...;
for (color = red; color <= violet; color++)
    ...;

int board[8][8];  // 声明一个内含int数组的数组
int ** ptr;       // 声明一个指向指针的指针，被指向的指针指向int
int * risks[10];  // 声明一个内含10个元素的数组，每个元素都是指向一个指向int的指针
int (* rusks)[10]; // 声明一个指向数组的指针，该数组含10个int类型的值
int * oof[3][4];   // 声明一个3*4的二维数组，每个数组都是指向int的指针
int (* uuf)[3][4]; // 声明一个指向3*4二维数组的指针，该数组中内含int类型值
int (* uof[3])[4]; // 声明一个内含3个指针元素的数组，其中每个指针都指向一个内含4个int类型元素的数组

void ToUpper(char *);  // 把字符串中的字符转换为大写字符
void (*pf) (char *); // pf是一个指向函数的指针
void *pf(char *); // pf是一个返回字符指针的函数

5/10 + 2/100 + 7/1000

1/2 + 0/4 + 1/8

0.5 + 0.00 + 0.125 = 0.625

flags = flags & MASK

flags = flags | MASK

flags = flags & ~MASK

flags = flags ^ MASK

(10001010) << 2 
(00101000)

struct {
    unsigned int autfd : 1;
    unsigned int bldfc : 1;
    unsigned int undln : 1;
    unsigned int itals : 1;
} prnt;

prnt.itals = 0;
prnt.undln = 1;

struct {
    unsigned int code1 : 2;
    unsigned int code2 : 2;
    unsigned int code3 : 8;
} prcode;
// 赋值方式
prcode.code1 = 0;
prcode.code2 = 3;
prcode.code3 = 102;

struct box_props {
    bool opaque                : 1;
    unsigned int fill_color    : 3;
    unsigned int               : 4;
    bool show_border           : 1;
    unsigned int border_color  : 3;
    unsigned int border_style  : 2;
    unsigned int               : 2;
};

#define TWO 2   /* 明示常量 */
#define FOUR TWO*TWO
#define PX printf("X is %d.\n", x)
#define FMT "X is %d.\n"

#define HAL 'Z' /* 定义字符常量 */
#define HAP "Z  /* 定义字符串(Z\0) */

#define FOUR 2*2 /* 一个记号: 2*2 */
#define SIX 2 * 3 /* 三个记号: 2、*、3 */

// 定义宏
#define SQUARE(X) X*X

// 使用宏
z = SQUARE(2);

int x = 5;
printf("The result is %d.\n", SQUARE(x+2));

#define PSQR(x) printf("The square of " #x " is %d.\n", ((x)*(x))

#define XNAME(n) x ## n
int XNAME(1) = 14; // 等价于int x1 = 14;

#define PR(...) printf(__VA_ARGS__)

#define MAX(X,Y) ((X) > (Y) ? (X) : (Y))
#define ABS(X) ((X) < 0 ? -(X) : (X))
#define ISSIGN(X) ((X) == '+' || (X) == '-' ? 1 : 0)

#include <stdio.h> // 文件名在尖括号中
#include "mystuff.h" // 文件名在双引号中

#include <stdio.h>       // 查找系统目录
#include "hot.h"         // 查找当前工作目录
#include "/usr/biff/p.h" // 查找/usr/biff/目录

#ifdef MAVIS
    #include "horse.h" // 如果已经用#define定义了MAVIS，则执行下面的指令
    #define STABLES 5
#else
    #include "cow.h" // 如果没有定义MAVIS，则执行下面的指令
    #define STABLES 15
#endif

#line 1000 //当前行号重置为1000
#line 10 "cool.c" //行号重置为10，文件名重置为cool.c

#if __STDC__VERSION != 201112L
#error Not C11
#endif

#pragma c9x on

#include <stdio.h>
inline static void eatline() // 内联函数定义/原型
{
    while (getchar() != '\n')
        continue;
}

int main()
{
    ...
    eatline();      //函数调用
    ...
}

#incldue <tgmath.h>
...
float x = 44.0;
double y;
y = sqrt(x);   // 调用宏，所以是sqrtf(x)
y = (sqrt)(x); // 调用函数sqrt()

void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *));

void *memcoy(void * restric s1, const void * restrict s2, size_t n);
void *memmove(void *s1, const void *s2, size_t n);

// 函数原型
void f1(int n, ...);

// double sum(int lim,...)
{
    va_list ap;        //声明一个存储参数的对象
    va_start(ap, lim); //把ap初始化为参数列表
    
    //检索参数
    double tic;
    int toc;
    ...
    tic = va_arg(ap, double);
    toc = va_arg(ap, int);
    
    va_end(ap); //清理工作
}

#define TSIZE 45 /* 存储的电影名数组大小 */
struct film {
    char title[TSIZE];
    int rating;
    struct film * next;
}

/* film2.c -- 使用结构链表 */
#include <stdio.h>
#include <stdlib.h> /* malloc() */
#include <string.h> /* strcpy() */
#define TSIZE 45    /* 存储片名的数组带下 */

struct film {
    char title[TSIZE];
    int rating;
    struct film * next; /* 指向链表中下一个结构 */
};
char * s_gets(char * st, int n);

int main(void)
{
    struct film * head = NULL;
    struct film * prev, *current;
    char input[TSIZE];

/* 收集并存储信息 */
    puts("Enter first movie title:");
    while (s_gets(input, TSIZE) != NULL && input[0] != '\0') /* 如果用户通过键盘模拟EOF或输入一行空行，将退出循环 */
    {
        /* 如果用户进行输入，程序就分配一个结构的空间，并将其地址赋给指针变量current */
        current = (struct film *) malloc(sizeof(struct file));
        /* 链表中第1个结构的地址应该存储在指针变量head中，随后每个结构的地址应该存储在其前一个结构的next成员中 */
        if (head == NULL) /* 第一个结构 */
            head = current
        else 
            prev->next = current;
        current->next = NULL; /*  */
        strcpy(current->title, input);
        puts("Enter your rating <0-10>:");
        scanf("%d", &current->rating);
        while (getchar() != '\n')
            continue;
        puts("Enter next movie title(empty line to stop)");
        prev = current;
    }
    
    /* 显示电影列表 */
    if (head == NULL)    /* 访问指针前先确保它为非空指针 */
        printf("No data entered. ");
    else
        printf("Here is the movie list:\n");
    current = head;  /* current表示当前指向的film指针 */
    while (current != NULL)
    {
        printf("Movie: %s Rating: %d\n",
            current->title, current->rating);
        current = current->next;
    }
    /* 完成任务，释放已分配的内存 */
    current = head;
    while (current != NULL)
    {
        current = head;
        head = current->next;
        free(current);
    }
    printf("Bye!\n");
    
    return 0;
}

char * s_gets(char * st, int n)
{
    char * ret_val;
    char * find;
    
    ret_val = fgets(st, n, stdin);
    if (ret_val)
    {
        find = strchar(st, '\n');   // 查找换行符
        if (find)
            *find = '\0';           // 如果地址不是NULL，则在此处放置一个空字符
        else
            while (getchar() != '\n')
                continue;          // 处理剩余输入行
    }
    return ret_val;
}

类型名：   简单链表
类型属性： 可以存储一系列项
类型操作： 
           -初始化链表为空
           -确定链表为空
           -确定链表已满
           -确定链表中的项数
           -在链表末尾添加项
           -在链表末尾添加项
           -遍历链表，处理链表中的项
           -请空链表

#define TSIZE 45 /* 存储电影名的数组大小 */
struct film
{
    char title[TSIZE];
    int rating;
};
typedef struct film Item;

typedef struct node
{
    Item item;
    struct node * next;
} Ndoe;
typedef Node * List;

List movies;

/* 操作：初始化一个链表 */
/* 前提条件：plist指向一个链表 */
/* 后置条件：该链表初始化为空 */
void InitiqalizeList(List * plist);

InitializeList(&movies);

/* list.h--简单链表类型的头文件 */
#ifndef LIST_H_
#define LIST_H_
#include <stdbool.h>

/* 特定程序的声明 */

#define TSIZE    45 /* 存储电影名的数组大小 */
struct film
{
    char title[TSIZE;
    int rating;
};

/* 一般类型定义 */
typedef struct film Item;

typedef struct node
{
    Item item;
    struct node * next;
} Node;

typedef Node * List;

/* 函数原型 */

/* 操作：初始化一个链表 */
/* 前提条件：plist指向一个链表 */
/* 后置条件：该链表初始化为空 */
void InitiqalizeList(List * plist);

/* 操作：确定链表是否为空 */
/* 后置条件： 为空返回true */
bool ListIsEmpty(const List *plist);

/* 操作：确定链表是否已满 */
bool ListIsFull(const List *plist);

/* 操作：确定链表中的项数 */
unsigned int ListItemCount(const List *plist);

/* 操作：在链表的末尾添加项 */
bool AddItem(Item item, List * plist);

/* 操作：把函数作用域链表中的每一个项 */
void Traverse(const List *plist, void(*pfun)(Item item));

/* 操作：释放了为链表分配的内存，将链表设置为空 */
void EmptyTheList(List * plist);

#endif

类型名：   队列
类型属性： 可以存储一系列项
类型操作： 
           -初始化队列为空
           -确定队列为空
           -确定队列已满
           -确定队列中的项数
           -在队列末尾添加项
           -在队列开头删除或者恢复项
           -请空队列

# 整数队列
typedef int Item;

typedef struct node
{
    Item item;
    struct node * next;
} Node;

typedef struct queue
{
    Node * front;  /* 指向队列首项的指针 */
    Node * rear;   /* 指向队列尾项的指针 */
    int items;     /* 队列中的项数 */
} Queue;

/* queue.h --Queue的接口 */
#ifndef _QUEUE_H_
#define _QUEUE_H_
#include <stdbool.h>

// Item类型的定义
typedef int Item;

# define MAXQUEUE 10 // 队列最大长度

typedef struct node
{
    Item item;
    struct node * next;
} Node;

typedef struct queue
{
    Node * front;  /* 指向队列首项的指针 */
    Node * rear;   /* 指向队列尾项的指针 */
    int items;     /* 队列中的项数 */
} Queue;

// 初始化队列
void InitializeQueue(Queue * pq);

// 检查队列是否已满
bool QueueIsFull(const Queue * pq);

// 检查队列是否为空
bool QueueIsEmpty(const Queue * pq);

// 确定队列中的项数
int QueueItemCount(const Queue * pq);

// 在队列末尾添加项
bool EnQueue(Item item, Queue * pq);

// 从队列开头添加项
bool DeQueue(Item *pitem, Queue * pq);

// 清空队列
void EmptyTheQueue(Queue * pq);

#endif

void InitializeQueue(Queue * pq)
{
    pq->front = pq->read = NULL;
    pq->items = 0;
}

void QueueIsFull(const Queue * pq)
{
    return pq->items == MAXQUEUE;
}

bool QueueIsEmpty(const Queue * pq)
{
    return pq->items == 0;
}

int QueueItemCount(const Queue * pq)
{
    return pq->items;
}

// 把项添加到队列末尾
// 1) 创建一个新节点
// 2) 把项拷贝到节点中
// 3) 设置节点的next为NULL, 表明该节点是最后一个节点
// 4) 设置当前节点的next指向新节点，把新节点链接到队列中
// 5) 把rear指针指向新节点，以便找到最后的节点
// 6) 项数 + 1

bool EnQueue(Item item, Queue * pq)
{
    Node * pnew;
    
    if (QueueIsFull(pq))
        return false;
    pnew = (Node *)malloc(sizeof(Node));
    if (pnew==Null)
    {
        fprintf(stderr,"Unable to allocate memory!\n");
        exit(1);
    }
    CotyToNode(item, pnew);
    pnew->next = NULL;
    if (QueueIsEmpty(pq))
        pq->front = pnew;
    else 
        pq->real->next = pnew;
    pq->rear = pnew;
    pq->items++;
    
    return true;
}

static void CopyToNode(Item item, Node * pn)
{
    pn->item = item;
}

bool DeQueue(Item * pitem, Queue * pq)
{
    Node * pt;
    
    if (QueueIsEmpty(pq))
        return false;
    CopyToItem(pq->front, pitem);
    pt = pt->front
    pq-> front = pq->front->next;
    free(pt);
    pq->items--;
    if (pq->items == 0)
        pq->rear = NULL;
    return true;
}

void EmptyTheQueue(Queue * pq)
{
    Item dummy;
    while (!QueueIsEmpty(pq))
        DeQueue(&dummy, pq);
    
}

类型名：   二叉查找树
类型属性： 二叉树要么是空节点的集合（空树），要么是有一个根节点的节点集合
           每个节点都有两个子树，叫做左子树和右子树
           每个子树本身也是一个二叉树或者空树
           二叉查找树是一个有序的二叉树，每个节点包含一个项
           左子树的所有项都在根节点项的前面，右子树的所有项都在根节点项的后面
类型操作： 初始化数为空
           确定树是否为空
           确定树是否已满
           确定树中的项数
           在树中添加一个项
           在树中删除一个项
           在树中查找一个项
           在树中访问一个项
           清空树

typedef SOMETHING Item;

typedef struct trnode
{
    Item item;
    struct trnode * left;
    struct trnode * right;
} Trn;

typedef struct tree
{
    Trnode * root;
    int size;
} Tree;

/* tree.h --二叉查找树 */
#ifndef _TREE_H_
#define _TREE_H_
#include <stdbool.h>

/* 根据具体情况重新定义 Item */
#define SLEN 20
typedef struct item
{
    char petname[SLEN];
    char petkind[SLEN];
} Item;

#define MAXITEMS 10

typedef struct trnode
{
    Item item;
    struct trnode * left;
    struct trnode * right;
} Trn;

typedef struct tree
{
    Trnode * root;
    int size;
} Tree;

void InitializeTree(Tree * ptree);

bool TreeIsEmpty(const Tree * ptree);

bool TreeIsFull(const Tree * ptree);

int TreeItemCount(const Tree * ptree);

bool AddItem(const Item * pi, Tree * ptree);

// 在树中查找一个项
bool InTree(const Item * pi, const Tree * ptree);

bool DeleteItem(cosnt Item * pi, Tree * ptree);

// 把函数应用于树中的每一项
void Traverse(const Tree * ptree, void(*pfun)(Item item));

void DeleteAll(Tree * ptree);

#endif

bool AddItem(const Item * pi, Tree * ptree)
{
    Trnode * new_node;
    if (TreeIsFull(ptree))
    {
        fprintf(stderr, "Tree is full\n");
        return false;
    }
    if (SeekItem(pi, ptree).child != NULL)
    {
        fprintf(stderr, "Attempted to add duplicate item\n");
        return false;
    }
    new_node = MakeNode(pi);  /* 指向新节点 */
    if (new_node == NULL)
    {
        fprintf(stderr, "Couldn't create node\n");
        return false;
    }
    /* 成功创建了一个新节点 */
    ptree->size++;
    if (ptree->root == NULL)
        ptree->root = new_node;
    else
        AddNode(new_node, ptree->root);
    return true;
}

// 参数是指向新项的指针，返回值是指向新节点的指针
static Trnode * MakeNode(const Item * pi)
{
    Trnode * new_node;
    new_node = (Trnode *) malloc(sizeof(Trnode));
    if (new_node != NULL)
    {
        new_node->item = *pi;
        new_node->left = NULL;
        new_node->right = NULL;
    }
    return new_node;
}

// 确定新节点的位置，然后添加新节点
// 其中ToLeft()和ToRight()函数依赖于Item本身的性质，用于比较两个Item的顺序关系
static void AddNode(Trnode * new_node, Trnode * root)
{
    if (ToLeft(&new_node->item, &root->item))
    {
        if (root->left == NULL)
            root->left = new_node;
        else
            AddNode(new_node, root->left);
    } 
    else if (ToRight(&new_node->item, &root->item))
    {
        if (root->right == NULL)
            root->right = new_node;
        else 
            AddNode(new_node, root->right);
    }
    else
    {
        fprintf(stderr, "location error in AddNode()\n");
        exit(1);
    }
}

typedef struct pair {
    Trnode * parent;
    Trnode * child;
} Pair;

static Pair SeekItem(const * pi, const Tree * ptree)
{
    // 从root节点开始查找
    Pair look;
    look.parent = NULL;
    look.child = ptree->root;
    
    if (look.child == NULL)
        return look;
    while (look.child != NULL)
    {
        if (ToLefe(pi, &(look.child->item)))
        {
            look.parent = look.child;
            look.child = look.child->left;
        }
        else if (ToRight(pi, &(look.child->item)))
        {
            look.parent = look.child;
            look.child = look.child->right;
        }
        else 
            break;  /* 如果前两种情况都不满足，则必定相等 */
    }
    return look;
}

bool InTree(const Item * pi, cosnt Tree * ptree)
{
    return (SeekItem(pi, ptree).child == NULL) ? false : true;
}

static void DeleteNode(Trnode **ptr)
/* ptr是指向目标节点的父节点指针成员的地址 */
{
    Trnode * temp;
    if ((*ptr)->left == NULL)
    {
        temp = *ptr;
        *ptr = (*ptr)->right;
        free(temp);
    }
    else if ((*ptr)->right == NULL)
    {
        temp = *ptr;
        *ptr = (*ptr)->left;
        free(temp);
    }
    else /* 被删除的节点有两个子节点 */
    {
        for (temp = (*ptr)->left; temp->right != NULL; temp = temp->right)
            continue;
        temp->right = (*ptr)->right;
        temp = *ptr;
        *ptr = (*ptr)->left;
        free(temp);
    }
}

bool DeleteItem(const Item * pi, Tree * ptree)
{
    pair look;
    look = SeekItem(pi, ptree);
    if (look.child == NULL)
        return false;
    if (look.parent == NULL) /* 删除根节点 */
        DeleteNode(&ptree->root);
    else if (look.parent->left ==look.child)
        DeleteNode(&look.parent->left);
    else 
        DeleteNode(&look.parent->right);
    ptree->size--;
    
    return true;
}

void Traverse(const Tree * ptree, void(*pfun)(Item item))
{
    if (ptree != NULL)
        InOrder(ptree->root, pfun);
}

static void InOrder(const Trnode * root, void(*pfun)(Item item))
{
    if (root != NULL)
    {
        InOrder(root->left, pfun);
        (*pfun)(root->item);
        InOrder(root->right, pfun);
    }
}

void DeleteAll(Tree * ptree)
{
    if (ptree != NULL)
        DeleteAllNodes(ptree->root);
    ptree-> root = NULL;
    ptree->size = 0;
}
static void DeleteAllNodes(Trnode * root)
{
    Trnode * pright;
    if (root != NULL)
    {
        pright = root->right;
        DeleteAllNodes(root->left);
        free(root);
        DeleteAllNodes(pright);
    }
}