抽象数据类型ADT(abstract data type)、链表、列表

在 2016年6月29日上张贴由 BestLove

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TSZIE 45
struct film
{
    char title[TSZIE];
    int rating;
    struct film *next;
};
int main(int argc, char const *argv[])
{
    struct film *head = NULL;
    struct film *prev, * current;
    char input[TSZIE];
    puts("Enter the title");
    while(gets(input) != NULL && input[0] != '\0')
    {
        current = (struct film *)malloc(sizeof(struct film));
        strcpy(current->title, input);
        if (head == NULL)
        {
            head = current;
        }
        else
        {
            prev->next = current;
        }
        current->next = NULL;
        puts("Enter the rating<0-10>");
        scanf("%d", &current->rating);
        while(getchar() != '\n')
        {
            continue;
        }
        puts("Enter the next title");
        prev = current;
    }
    if (head == NULL)
    {
        puts("no films");
        return 1;
    }
    current = head;
    while(current != NULL)
    {
        printf("title:%s\n", current->title);
        printf("rating:%d\n", current->rating);
        current = current->next;
    }
    current = head;
    while(current != NULL)
    {
        free(current);
        current = current->next;
    }
    puts("done");
    return 0;
}

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#define TSZIE 45

struct film

{

char title[TSZIE];

int rating;

struct film *next;

};

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

{

struct film *head = NULL;

struct film *prev, * current;

char input[TSZIE];

puts("Enter the title");

while(gets(input) != NULL && input[0] != '\0')

{

current = (struct film *)malloc(sizeof(struct film));

strcpy(current->title, input);

if (head == NULL)

{

head = current;

}

else

{

prev->next = current;

}

current->next = NULL;

puts("Enter the rating<0-10>");

scanf("%d", &current->rating);

while(getchar() != '\n')

{

continue;

}

puts("Enter the next title");

prev = current;

}

if (head == NULL)

{

puts("no films");

return 1;

}

current = head;

while(current != NULL)

{

printf("title:%s\n", current->title);

printf("rating:%d\n", current->rating);

current = current->next;

}

current = head;

while(current != NULL)

{

free(current);

current = current->next;

}

puts("done");

return 0;

}

#ifndef LIST_H_
//标记变量，防止list.h被重复#include
#define LIST_H_
#include <stdbool.h>    //c99特性
#define TSZIE 45        //特定于程序的声明，存放影片名的数组大小
struct film
{
    char title[TSZIE];
    int rating;
};
typedef struct film Item;   //一般类型定义

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

typedef Node * List;
/*
    操作：初始化一个列表
    操作前：plist指向一个列表
    操作后：该列表被初始化为空列表
*/
void InitializeList(List * plist);

/*
    操作：确定列表是否为空列表
    操作前：plist指向一个已初始化的列表
    操作后：如果该列表为空则返回true，否则返回false
*/
bool ListIsEmpty(const List * plist);

/*
    操作：确定列表中的项目的个数
    操作前：plist指向一个已初始化的列表
    操作后：返回该列表中项目的个数
*/
unsigned int ListItemCount(const List * plist);

/*
    操作：在列表尾部添加一个项目
    操作前：item是要被增加到列表的项目
            plist指向一个已初始化的列表
    操作后：如果可能的话，在列表尾部添加一个新项目，
            函数返回true，否则函数返回false
*/
bool AddItem(Item item, List * plist);

/*
    操作：把一个函数作用于列表中的每个项目
    操作前：plist指向一个已初始化的列表
            pfun指向一个函数，该函数接受
            一个Item参数并且无返回值
    操作后：pfun指向的函数被作用到
            列表中的每个项目一次
 */
void Traverse(const List * plist, void(* pfun)(Item item));

/*
    操作：释放已分配的内存(如果有)
    操作前：plist指向一个已初始化的列表
    操作后：为该列表分配的内存已被释放
            并且该列表被置为空列表
 */
void EmptyTheList(List * plist);

#endif

#ifndef LIST_H_

//标记变量，防止list.h被重复#include

#define LIST_H_

#include <stdbool.h> //c99特性

#define TSZIE 45 //特定于程序的声明，存放影片名的数组大小

struct film

{

char title[TSZIE];

int rating;

};

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

typedef struct node

{

Item item;

struct node * next;

} Node;

typedef Node * List;

操作：初始化一个列表

操作前：plist指向一个列表

操作后：该列表被初始化为空列表

void InitializeList(List * plist);

操作：确定列表是否为空列表

操作前：plist指向一个已初始化的列表

操作后：如果该列表为空则返回true，否则返回false

bool ListIsEmpty(const List * plist);

操作：确定列表中的项目的个数

操作前：plist指向一个已初始化的列表

操作后：返回该列表中项目的个数

unsigned int ListItemCount(const List * plist);

操作：在列表尾部添加一个项目

操作前：item是要被增加到列表的项目

plist指向一个已初始化的列表

操作后：如果可能的话，在列表尾部添加一个新项目，

函数返回true，否则函数返回false

bool AddItem(Item item, List * plist);

操作：把一个函数作用于列表中的每个项目

操作前：plist指向一个已初始化的列表

pfun指向一个函数，该函数接受

一个Item参数并且无返回值

操作后：pfun指向的函数被作用到

列表中的每个项目一次

void Traverse(const List * plist, void(* pfun)(Item item));

操作：释放已分配的内存(如果有)

操作前：plist指向一个已初始化的列表

操作后：为该列表分配的内存已被释放

并且该列表被置为空列表

void EmptyTheList(List * plist);

#endif

#include <stdio.h>
#include <stdlib.h>
#include "list.h"

//局部函数原型
static void CopyToNode(Item item, Node * pnode);

void InitializeList(List * plist)
{
    *plist = NULL;
}

bool ListIsEmpty(const List * plist)
{
    if (*plist == NULL)
    {
        return true;
    } else {
        return false;
    }
}

unsigned int ListItemCount(const List * plist)
{
    unsigned int count = 0;
    Node * pnode = *plist;  //设置到列表的开始处
    while(pnode != NULL)
    {
        ++count;
        pnode = pnode->next;
    }
    return count;
}

bool AddItem(Item item, List * plist)
{
    Node * pnew;
    Node * scan = *plist;
    pnew = (Node *)malloc(sizeof(Node));
    if (pnew == NULL)
    {
        return false;
    }
    CopyToNode(item, pnew);
    pnew->next = NULL;
    if (scan == NULL)
    {
        *plist = pnew;
    } else {
        while(scan->next != NULL)
        {
            scan = scan->next;
        }
        scan->next = pnew;
    }
    return true;
}

void Traverse(const List * plist, void(* pfun)(Item item))
{
    Node * pnode = *plist;
    while(pnode != NULL)
    {
        (* pfun)(pnode->item);  //调用函数，操作列表中的项目
        pnode = pnode->next;
    }
}

void EmptyTheList(List * plist)
{
    Node * psave;
    while(*plist != NULL)
    {
        psave = (*plist)->next;
        free(*plist);
        *plist = psave;
    }
}

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

#include <stdio.h>

#include <stdlib.h>

#include "list.h"

//局部函数原型

static void CopyToNode(Item item, Node * pnode);

void InitializeList(List * plist)

{

*plist = NULL;

}

bool ListIsEmpty(const List * plist)

{

if (*plist == NULL)

{

return true;

} else {

return false;

}

unsigned int ListItemCount(const List * plist)

{

unsigned int count = 0;

Node * pnode = *plist; //设置到列表的开始处

while(pnode != NULL)

{

++count;

pnode = pnode->next;

}

return count;

}

bool AddItem(Item item, List * plist)

{

Node * pnew;

Node * scan = *plist;

pnew = (Node *)malloc(sizeof(Node));

if (pnew == NULL)

{

return false;

}

CopyToNode(item, pnew);

pnew->next = NULL;

if (scan == NULL)

{

*plist = pnew;

} else {

while(scan->next != NULL)

{

scan = scan->next;

}

scan->next = pnew;

}

return true;

}

void Traverse(const List * plist, void(* pfun)(Item item))

{

Node * pnode = *plist;

while(pnode != NULL)

{

(* pfun)(pnode->item); //调用函数，操作列表中的项目

pnode = pnode->next;

}

void EmptyTheList(List * plist)

{

Node * psave;

while(*plist != NULL)

{

psave = (*plist)->next;

free(*plist);

*plist = psave;

}

static void CopyToNode(Item item, Node * pnode)

{

pnode->item = item;

}

// gcc -c list.c    
// gcc main.c list.o
#include <stdio.h>
#include <stdlib.h>
#include "list.h"
void showmovies(Item item);
int main(int argc, char const *argv[])
{
    List movies;
    Item temp;
    InitializeList(&movies);
    puts("Enter first movie title:");
    while(gets(temp.title) != NULL && temp.title[0] != '\0')
    {
        puts("Enter your rating <0-10>:");
        scanf("%d", &temp.rating);
        while(getchar() != '\n')
        {
            continue;
        }
        if (AddItem(temp, &movies) == false)
        {
            fprintf(stderr, "Problem allocating memory\n");
            break;
        }
        puts("Enter next movie title(epmty line to stop)");
    }
    if (ListIsEmpty(&movies))
    {
        puts("No data entered");
    } else {
        puts("here is the movie list");
        Traverse(&movies, showmovies);
    }
    printf("you entered %d movies\n", ListItemCount(&movies));
    EmptyTheList(&movies);
    puts("done");
    return 0;
}
void showmovies(Item item)
{
    printf("movie:%s rating:%d\n", item.title, item.rating);
}

// gcc -c list.c

// gcc main.c list.o

#include <stdio.h>

#include <stdlib.h>

#include "list.h"

void showmovies(Item item);

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

{

List movies;

Item temp;

InitializeList(&movies);

puts("Enter first movie title:");

while(gets(temp.title) != NULL && temp.title[0] != '\0')

{

puts("Enter your rating <0-10>:");

scanf("%d", &temp.rating);

while(getchar() != '\n')

{

continue;

}

if (AddItem(temp, &movies) == false)

{

fprintf(stderr, "Problem allocating memory\n");

break;

}

puts("Enter next movie title(epmty line to stop)");

}

if (ListIsEmpty(&movies))

{

puts("No data entered");

} else {

puts("here is the movie list");

Traverse(&movies, showmovies);

}

printf("you entered %d movies\n", ListItemCount(&movies));

EmptyTheList(&movies);

puts("done");

return 0;

}

void showmovies(Item item)

{

printf("movie:%s rating:%d\n", item.title, item.rating);

}

基础了解(二十)

在 2016年6月29日2016年6月29日上张贴由 BestLove

// atexit(ptr) 注册退出事件
#include <stdio.h>
#include <stdlib.h>
void event1(void);
void event2(void);
int main(int argc, char const *argv[])
{
    atexit(event1);
    atexit(event2);
    /*
        当程序主动调用exit()或main函数中return触发exit()后
        会后进先出地执行被注册到atexit()中的函数
        this is the event2
        this is the event1
     */
    return 0;
}
void event1(void)
{
    puts("this is the event1");
}
void event2(void)
{
    puts("this is the event2");
}

// 快速排序qsort(数组指针,数组长度,单个数组元素长度,自定义排序函数指针)
#include <stdio.h>
#include <stdlib.h>
#define NUM 40
void fillarray(double ar[], int n);
void showarray(const double ar[], int n);
int mycomp(const void * p1, const void * p2);
int main(int argc, char const *argv[])
{
    double vals[NUM];
    fillarray(vals, NUM);
    puts("Random list:");
    showarray(vals, NUM);
    qsort(vals, NUM, sizeof(double), mycomp);
    puts("\nSorted list:");
    showarray(vals, NUM);
    return 0;
}
void fillarray(double ar[], int n)
{
    int i;
    for (i = 0; i < n; ++i)
    {
        ar[i] = (double)rand() / ((double)rand() + 0.1);
    }
}
void showarray(const double ar[], int n)
{
    int i;
    for (i = 0; i < n; ++i)
    {
        printf("%9.4f ", ar[i]);
        if (i % 6 == 5)
        {
            putchar('\n');
        }
    }
}
int mycomp(const void * p1, const void * p2)
{
    // 需要使用指向double的指针访问值
    const double * a1 = (const double *)p1;
    const double * a2 = (const double *)p2;
    if (*a1 < *a2)
    {
        return -1;
    } else if (*a1 == *a2)
    {
        return 0;
    } else {
        return 1;
    }
}

// 诊断库(用于调试)
#include <stdio.h>
#define NDEBUG  //如果调试完毕，直接在包含assert.h之前定义宏NDEBUG，就能禁用assert()功能
#include <assert.h>
int main(int argc, char const *argv[])
{
    int i = 0;
    assert(i == 0);
    puts("ok");
    // 断言当i=0时，程序直接退出，输出相关错误信息(文件名、行号)
    assert(i != 0);
    puts("done");
    return 0;
}

// 可变参数 stdarg.h
#include <stdio.h>
#include <stdarg.h>
double sum(int, ...);
int main(int argc, char const *argv[])
{
    /*
        在函数原型中使用省略号
        在函数定义中创建一个va_list类型的变量
        用宏将该变量初始化为一个参数列表
        用宏访问这个参数列表
        用宏完成清理工作
        void f1(int n, ...);                        //合法
        int f2(int n, const char * s, ...);         //合法
        char f3(char c1, ..., char c2);             //不合法，省略号必须是最后一个参量
        double f4();                                //不合法，没有任何参量
     */
    double s, t;
    // 第一个参数3，描述了后面有3个可变参数
    // printf()中估计是统计%d、%s等的数量，来计算出可变参数数量的
    s = sum(3, 1.1, 2.5, 13.3);
    t = sum(6, 1.1, 2.1, 13.1, 4.1, 5.1, 6.1);
    printf("return value for sum(3, 1.1, 2.5, 13.3) %g\n", s);
    printf("return value for sum(6, 1.1, 2.1, 13.1, 4.1, 5.1, 6.1) %g\n", t);
    return 0;
}
double sum(int lim, ...)
{
    va_list ap;             //声明用于存放参数的变量
    double tot = 0;
    int i;
    va_start(ap, lim);      //把ap初始化为参数列表
    for (i = 0; i < lim; ++i)
    {
        tot += va_arg(ap, double);  //访问参数列表中的每一个选项
    }
    va_end(ap);             //清理工作
    return tot;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

// atexit(ptr) 注册退出事件

#include <stdio.h>

#include <stdlib.h>

void event1(void);

void event2(void);

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

{

atexit(event1);

atexit(event2);

当程序主动调用exit()或main函数中return触发exit()后

会后进先出地执行被注册到atexit()中的函数

this is the event2

this is the event1

return 0;

}

void event1(void)

{

puts("this is the event1");

}

void event2(void)

{

puts("this is the event2");

}

// 快速排序qsort(数组指针,数组长度,单个数组元素长度,自定义排序函数指针)

#include <stdio.h>

#include <stdlib.h>

#define NUM 40

void fillarray(double ar[], int n);

void showarray(const double ar[], int n);

int mycomp(const void * p1, const void * p2);

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

{

double vals[NUM];

fillarray(vals, NUM);

puts("Random list:");

showarray(vals, NUM);

qsort(vals, NUM, sizeof(double), mycomp);

puts("\nSorted list:");

showarray(vals, NUM);

return 0;

}

void fillarray(double ar[], int n)

{

int i;

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

{

ar[i] = (double)rand() / ((double)rand() + 0.1);

}

void showarray(const double ar[], int n)

{

int i;

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

{

printf("%9.4f ", ar[i]);

if (i % 6 == 5)

{

putchar('\n');

}

int mycomp(const void * p1, const void * p2)

{

// 需要使用指向double的指针访问值

const double * a1 = (const double *)p1;

const double * a2 = (const double *)p2;

if (*a1 < *a2)

{

return -1;

} else if (*a1 == *a2)

{

return 0;

} else {

return 1;

}

// 诊断库(用于调试)

#include <stdio.h>

#define NDEBUG //如果调试完毕，直接在包含assert.h之前定义宏NDEBUG，就能禁用assert()功能

#include <assert.h>

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

{

int i = 0;

assert(i == 0);

puts("ok");

// 断言当i=0时，程序直接退出，输出相关错误信息(文件名、行号)

assert(i != 0);

puts("done");

return 0;

}

// 可变参数 stdarg.h

#include <stdio.h>

#include <stdarg.h>

double sum(int, ...);

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

{

在函数原型中使用省略号

在函数定义中创建一个va_list类型的变量

用宏将该变量初始化为一个参数列表

用宏访问这个参数列表

用宏完成清理工作

void f1(int n, ...); //合法

int f2(int n, const char * s, ...); //合法

char f3(char c1, ..., char c2); //不合法，省略号必须是最后一个参量

double f4(); //不合法，没有任何参量

double s, t;

// 第一个参数3，描述了后面有3个可变参数

// printf()中估计是统计%d、%s等的数量，来计算出可变参数数量的

s = sum(3, 1.1, 2.5, 13.3);

t = sum(6, 1.1, 2.1, 13.1, 4.1, 5.1, 6.1);

printf("return value for sum(3, 1.1, 2.5, 13.3) %g\n", s);

printf("return value for sum(6, 1.1, 2.1, 13.1, 4.1, 5.1, 6.1) %g\n", t);

return 0;

}

double sum(int lim, ...)

{

va_list ap; //声明用于存放参数的变量

double tot = 0;

int i;

va_start(ap, lim); //把ap初始化为参数列表

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

{

tot += va_arg(ap, double); //访问参数列表中的每一个选项

}

va_end(ap); //清理工作

return tot;

}

基础了解(十九)

在 2016年6月28日2016年6月28日上张贴由 BestLove

// #ifndef常见用法，防止包含多个文件或多次包含同一文件后重复定义
#include <stdio.h>
#ifndef _STDIO_H    //通常用文件名、下划线定义宏
    #define _STDIO_H
    // ... 其他定义
#endif
int main(int argc, char const *argv[])
{
    return 0;
}

// #if #elif #if defined()
#include <stdio.h>
#define FLAG 3
#if FLAG == 1
    #include <string.h>
#elif FLAG == 2
    // ...
#elif FLAG == 3
    // ...
#else
    // ...
#endif
// 使用 if defined()代替 ifdef 语法的好处就是可以使用elif
#if defined(FLAG)
    // ...
#elif defined(VAX)
    // ...
#elif defined(MAC)
    // ...
#else
    // ...
#endif
int main(int argc, char const *argv[])
{
    return 0;
}

// 预定义宏 __DATE__  __FILE__  __LINE__  __STDC__  __STDC_HOSTED__  __STDC_VERSION__  __TIME__
// c99 __func__(预定义标识符，具有函数作用域)
#include <stdio.h>
void why_me();
int main(int argc, char const *argv[])
{
    printf("the file is %s\n", __FILE__);
    printf("the date is %s\n", __DATE__);
    printf("the time is %s\n", __TIME__);
    printf("this version is %ld\n", __STDC_HOSTED__);
    printf("this is line %d\n", __LINE__);
    printf("this fucntion is %s\n", __func__);
    why_me();
    return 0;
}
void why_me()
{
    printf("this is line %d\n", __LINE__);
    printf("this fucntion is %s\n", __func__);
}

// #line指令用于重置由__LINE__和__FILE__宏报告的行号和文件名
#include <stdio.h>
#line 1000              //把当前行号重置为1000
#line 10 "cool.c"       //把行号重置为10，文件名重置为cool.c
int main(int argc, char const *argv[])
{
    return 0;
}

// 如果version不是C99中断编译
#include <stdio.h>
#if __STDC_VERSION__ != 199901L
#error Not C99
#endif
int main(int argc, char const *argv[])
{
    return 0;
}

// 在现代编译器中，可用命令行参数或IDE菜单修改编译器的某些配置
// 也可用 #pragma 将编译器指令置于源代码中
#include <stdio.h>
// 在开发C99时 用C9X代表C99 编译器可以使用pragma来启用对C9X的支持
#pragma c9x on
// c99提供了_Pragma预处理器运算符
_Pragma("nonstandardtreatmenttypeB on")
// 等价于
#pragma nonstandardtreatmenttypeB on 
// 如果没有定义LIMIT宏，编译时提示LIMIT not be defined
#ifndef LIMIT
#pragma message("LIMIT not be defined")
#endif
int main(int argc, char const *argv[])
{
    return 0;
}

// #ifndef常见用法，防止包含多个文件或多次包含同一文件后重复定义

#include <stdio.h>

#ifndef _STDIO_H //通常用文件名、下划线定义宏

#define _STDIO_H

// ... 其他定义

#endif

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

{

return 0;

}

// #if #elif #if defined()

#include <stdio.h>

#define FLAG 3

#if FLAG == 1

#include <string.h>

#elif FLAG == 2

// ...

#elif FLAG == 3

// ...

#else

// ...

#endif

// 使用 if defined()代替 ifdef 语法的好处就是可以使用elif

#if defined(FLAG)

// ...

#elif defined(VAX)

// ...

#elif defined(MAC)

// ...

#else

// ...

#endif

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

{

return 0;

}

// 预定义宏 __DATE__ __FILE__ __LINE__ __STDC__ __STDC_HOSTED__ __STDC_VERSION__ __TIME__

// c99 __func__(预定义标识符，具有函数作用域)

#include <stdio.h>

void why_me();

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

{

printf("the file is %s\n", __FILE__);

printf("the date is %s\n", __DATE__);

printf("the time is %s\n", __TIME__);

printf("this version is %ld\n", __STDC_HOSTED__);

printf("this is line %d\n", __LINE__);

printf("this fucntion is %s\n", __func__);

why_me();

return 0;

}

void why_me()

{

printf("this is line %d\n", __LINE__);

printf("this fucntion is %s\n", __func__);

}

// #line指令用于重置由__LINE__和__FILE__宏报告的行号和文件名

#include <stdio.h>

#line 1000 //把当前行号重置为1000

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

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

{

return 0;

}

// 如果version不是C99中断编译

#include <stdio.h>

#if __STDC_VERSION__ != 199901L

#error Not C99

#endif

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

{

return 0;

}

// 在现代编译器中，可用命令行参数或IDE菜单修改编译器的某些配置

// 也可用 #pragma 将编译器指令置于源代码中

#include <stdio.h>

// 在开发C99时用C9X代表C99 编译器可以使用pragma来启用对C9X的支持

#pragma c9x on

// c99提供了_Pragma预处理器运算符

_Pragma("nonstandardtreatmenttypeB on")

// 等价于

#pragma nonstandardtreatmenttypeB on

// 如果没有定义LIMIT宏，编译时提示LIMIT not be defined

#ifndef LIMIT

#pragma message("LIMIT not be defined")

#endif

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

{

return 0;

}

基础了解(十八)

在 2016年6月28日2016年7月13日上张贴由 BestLove

// #define #include #ifdef #else #endif #ifndef #if #elif #line #error #pragma
// sqrt() atan() atan2() exit() atexit() assert() memcpy() memmove() va_start()
// va_arg() va_copy() va_end()
// C预处理器的更多功能
// 类函数宏和条件编译
// 内联函数
// C库概述和其中一些方便的函数
#include <stdio.h>
#define TWO 2   // 注释 预处理语句以#开头
/*反斜杠可以把这个定义延续到下一行(反斜杠后页面显示有点问题，所以注释了)
#define OW "Consistency is the last refuge of the unimagina\
tive. -Oscar Wilde"    
*/ 
#define FOUR TWO*TWO
#define PX printf("X is %d\n", x)
#define FMT "X is %d \n"
int main(int argc, char const *argv[])
{
    // 每个#define行(逻辑行)由三部分组成。
    // 1.#define本身
    // 2.所选择的缩略词(宏macro) 本例中的宏代表值，称为对象宏(object-like macro) C还有类函数宏
    // 3.第三部分称为替换列表或主体
    // 预处理器在程序中发现宏以后，会用实体代替该宏(有一种例外)
    int x = TWO;
    PX;
    x = FOUR;
    printf(FMT, x);
    printf("%s\n", OW);
    printf("TWO:OW\n");
    /*  宏可以替换常量、表达式、字符串等
        X is 2
        X is 4      //宏不进行任何计算 计算是在替换以后 运行代码后 2*2得出
        Consistency is the last refuge of the unimaginative. -Oscar Wilde
        TWO:OW      //引号中会被认为是字符串常量，不进行替换
     */
    return 0;
}

// 类函数宏
#include <stdio.h>
// SQUARE为宏标识符 括号中的X为宏的参数 X*X为替换列表
#define SQUARE(X) X*X
#define PR(X) printf("The result is %d.\n", X);
int main(int argc, char const *argv[])
{
    int z;
    z = SQUARE(x);
    PR(z);
    z= SQUARE(2);
    PR(z);
    PR(SQUARE(x+2));
    PR(100/SQUARE(2));
    PR(SQUARE(++x));
    /*
        The result is 16.
        The result is 4.
        The result is 14.   //替换成 x+2*x+2=4+2*4+2 (宏不进行计算、只进行替换)
        The result is 100.  //100/2*2
        The result is 36.   //++x*++x 进行了两次增量后 6*6=36，有些编译器：5*6=30
     */
    return 0;
}

//类宏函数引号中使用宏参数"string" #PARAM "string"
#include <stdio.h>
#define PR(X) printf("the square of " #X " is %d\n", ((X)*(X)));
int main(int argc, char const *argv[])
{
    int y = 5;
    PR(y);
    PR(2 + 4);
    /*
        ((X)*(X)))可以避免上例中的SQUARE(x+2) 100/SQUARE(2)但是不能避免SQUARE(++x)
        the square of y is 25
        the square of 2 + 4 is 36
     */
    //使用宏和函数的抉择(时间和空间的抉择)
    //调用宏20次，会把20行代码插入程序中(浪费空间)
    //调用函数20次，只有一份函数拷贝，但程序的控制会转移到函数中随后返回调用程序(浪费时间)
    //宏有一个优点，不检查变量类型(宏处理替换字符串，而不是实际值)
    //总结：很短的函数、比较追求性能，可以使用宏（但是需要注意宏是否会引起重大差异，如上例）
    //c99还提供了内联函数(跟类函数宏效果类似)
    //inline void test() 增加inline关键字即可
    return 0;
}

//do while在类宏函数中的用法
#include <stdio.h>
#define TEST(a,b) a++;b++;
#define TEST1(a,b)       \
do {                     \
    a++;b++;             \
} while(0)               \
int main(int argc, char const *argv[])
{
    int a = 1;
    int b = 2;
    if (1==1)
        //如果这里使用TEST(a,b);会编译出错，因为if条件没有使用大括号但是后面跟了a++;b++;
        //所以，很多类宏函数通常使用do{}while(0)写法来达到更好的兼容性
        TEST1(a,b);
    else 
        int c = 3;
    printf("%d %d\n", a, b);
    return 0;
}

//预处理的粘合剂：##运算符
#include <stdio.h>
#define XNAME(n) x ## n
#define PRINT_XN(n) printf("x" #n " = %d\n", x ## n);
int main(int argc, char const *argv[])
{
    int XNAME(1) = 14;
    int XNAME(2) = 20;
    PRINT_XN(1);
    PRINT_XN(2);
    /*
        x1 = 14
        x2 = 20
     */
    return 0;
}

//可变宏：...和__VA_ARGS__
#include <stdio.h>
#include <math.h>
#define PR(X, ...) printf("Message " #X ": " __VA_ARGS__);
int main(int argc, char const *argv[])
{
    double x = 48;
    double y;
    y = sqrt(x);
    PR(1, "x=%g\n", x);
    PR(2, "x=%.2f,y=%.4f\n", x, y);
    /*
        Message 1: x=48  //替换后printf("Message " "1" ": " "x=%g\n", x)
        Message 2: x=48.00,y=6.9282
     */
    return 0;
}

// #include文件包含
#include <stdio.h>
int main(int argc, char const *argv[])
{
    /*
        #include <stdio.h>                  //搜索系统目录
        #include "test.h"                   //搜索当前工作目录
        #include "/usr/local/test.h"        //搜索/usr/local目录
        具体搜索哪些目录，不同编译器可能有不同结果
     */
    return 0;
}

#include <stdio.h>
#define LIMIT 400
//取消LIMIT定义，如果之前没有定义LIMIT，这句语句也是合法的，不确定的情况下可以先取消再定义更为保险
#undef LIMIT
#ifdef MAVIS
    #include "horse.h"  //如果已经用#define定义了MAVIS，则执行这里的指令
    #define STABLES 5
#else
    #include "cow.h"    //如果没有用#define定义了MAVIS，则执行这里的指令
    #define STABLES 15
#endif
#define JUST_CHECKING
#define LIMIT 4
int main(int argc, char const *argv[])
{
    /*
        不同的工作环境使用不同的C程序或C库包
        改变一些#define宏的值后，这些代码就可以被移植到另一个系统
        #undef指令取消前面的#define定义
        __DATE__和__FILE__等预定义宏，不能被取消
        #if #ifdef #ifndef #else #elif #endif指令可用于选择什么情况下编译哪些代码
        #line指令用于重置行和文件信息
        #error指令用于给出错误信息
        #pragma指令用于向编译器发出提示
     */
    int i;
    int total = 0;
    for (int i = 1; i < LIMIT; ++i)
    {
        total += 2 * i * i + 1;
        #ifdef JUST_CHECKING    //代码块中也可以使用
            printf("i=%d running total=%d\n", i, total);
        #endif
    }
    printf("Grand total=%d\n", total);
    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

// #define #include #ifdef #else #endif #ifndef #if #elif #line #error #pragma

// sqrt() atan() atan2() exit() atexit() assert() memcpy() memmove() va_start()

// va_arg() va_copy() va_end()

// C预处理器的更多功能

// 类函数宏和条件编译

// 内联函数

// C库概述和其中一些方便的函数

#include <stdio.h>

#define TWO 2 // 注释预处理语句以#开头

/*反斜杠可以把这个定义延续到下一行(反斜杠后页面显示有点问题，所以注释了)

#define OW "Consistency is the last refuge of the unimagina\

tive. -Oscar Wilde"

#define FOUR TWO*TWO

#define PX printf("X is %d\n", x)

#define FMT "X is %d \n"

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

{

// 每个#define行(逻辑行)由三部分组成。

// 1.#define本身

// 2.所选择的缩略词(宏macro) 本例中的宏代表值，称为对象宏(object-like macro) C还有类函数宏

// 3.第三部分称为替换列表或主体

// 预处理器在程序中发现宏以后，会用实体代替该宏(有一种例外)

int x = TWO;

PX;

x = FOUR;

printf(FMT, x);

printf("%s\n", OW);

printf("TWO:OW\n");

/* 宏可以替换常量、表达式、字符串等

X is 2

X is 4 //宏不进行任何计算计算是在替换以后运行代码后 2*2得出

Consistency is the last refuge of the unimaginative. -Oscar Wilde

TWO:OW //引号中会被认为是字符串常量，不进行替换

return 0;

}

// 类函数宏

#include <stdio.h>

// SQUARE为宏标识符括号中的X为宏的参数 X*X为替换列表

#define SQUARE(X) X*X

#define PR(X) printf("The result is %d.\n", X);

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

{

int z;

z = SQUARE(x);

PR(z);

z= SQUARE(2);

PR(z);

PR(SQUARE(x+2));

PR(100/SQUARE(2));

PR(SQUARE(++x));

The result is 16.

The result is 4.

The result is 14. //替换成 x+2*x+2=4+2*4+2 (宏不进行计算、只进行替换)

The result is 100. //100/2*2

The result is 36. //++x*++x 进行了两次增量后 6*6=36，有些编译器：5*6=30

return 0;

}

//类宏函数引号中使用宏参数"string" #PARAM "string"

#include <stdio.h>

#define PR(X) printf("the square of " #X " is %d\n", ((X)*(X)));

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

{

int y = 5;

PR(y);

PR(2 + 4);

((X)*(X)))可以避免上例中的SQUARE(x+2) 100/SQUARE(2)但是不能避免SQUARE(++x)

the square of y is 25

the square of 2 + 4 is 36

//使用宏和函数的抉择(时间和空间的抉择)

//调用宏20次，会把20行代码插入程序中(浪费空间)

//调用函数20次，只有一份函数拷贝，但程序的控制会转移到函数中随后返回调用程序(浪费时间)

//宏有一个优点，不检查变量类型(宏处理替换字符串，而不是实际值)

//总结：很短的函数、比较追求性能，可以使用宏（但是需要注意宏是否会引起重大差异，如上例）

//c99还提供了内联函数(跟类函数宏效果类似)

//inline void test() 增加inline关键字即可

return 0;

}

//do while在类宏函数中的用法

#include <stdio.h>

#define TEST(a,b) a++;b++;

#define TEST1(a,b) \

do { \

a++;b++; \

} while(0) \

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

{

int a = 1;

int b = 2;

if (1==1)

//如果这里使用TEST(a,b);会编译出错，因为if条件没有使用大括号但是后面跟了a++;b++;

//所以，很多类宏函数通常使用do{}while(0)写法来达到更好的兼容性

TEST1(a,b);

else

int c = 3;

printf("%d %d\n", a, b);

return 0;

}

//预处理的粘合剂：##运算符

#include <stdio.h>

#define XNAME(n) x ## n

#define PRINT_XN(n) printf("x" #n " = %d\n", x ## n);

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

{

int XNAME(1) = 14;

int XNAME(2) = 20;

PRINT_XN(1);

PRINT_XN(2);

x1 = 14

x2 = 20

return 0;

}

//可变宏：...和__VA_ARGS__

#include <stdio.h>

#include <math.h>

#define PR(X, ...) printf("Message " #X ": " __VA_ARGS__);

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

{

double x = 48;

double y;

y = sqrt(x);

PR(1, "x=%g\n", x);

PR(2, "x=%.2f,y=%.4f\n", x, y);

Message 1: x=48 //替换后printf("Message " "1" ": " "x=%g\n", x)

Message 2: x=48.00,y=6.9282

return 0;

}

// #include文件包含

#include <stdio.h>

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

{

#include <stdio.h> //搜索系统目录

#include "test.h" //搜索当前工作目录

#include "/usr/local/test.h" //搜索/usr/local目录

具体搜索哪些目录，不同编译器可能有不同结果

return 0;

}

#include <stdio.h>

#define LIMIT 400

//取消LIMIT定义，如果之前没有定义LIMIT，这句语句也是合法的，不确定的情况下可以先取消再定义更为保险

#undef LIMIT

#ifdef MAVIS

#include "horse.h" //如果已经用#define定义了MAVIS，则执行这里的指令

#define STABLES 5

#else

#include "cow.h" //如果没有用#define定义了MAVIS，则执行这里的指令

#define STABLES 15

#endif

#define JUST_CHECKING

#define LIMIT 4

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

{

不同的工作环境使用不同的C程序或C库包

改变一些#define宏的值后，这些代码就可以被移植到另一个系统

#undef指令取消前面的#define定义

__DATE__和__FILE__等预定义宏，不能被取消

#if #ifdef #ifndef #else #elif #endif指令可用于选择什么情况下编译哪些代码

#line指令用于重置行和文件信息

#error指令用于给出错误信息

#pragma指令用于向编译器发出提示

int i;

int total = 0;

for (int i = 1; i < LIMIT; ++i)

{

total += 2 * i * i + 1;

#ifdef JUST_CHECKING //代码块中也可以使用

printf("i=%d running total=%d\n", i, total);

#endif

}

printf("Grand total=%d\n", total);

return 0;

}

基础了解(十七)

在 2016年6月21日2016年6月27日上张贴由 BestLove

// 运算符 ~ & | ^ >> << &= |= ^= >>= <<=
// 二进制、十进制、十六进制
// 位运算符、位字段
// 字符串累加（int数组合并成字符串）
#include <stdio.h>
int main(int argc, char const *argv[])
{
    /*
        十进制数        十六进制数       八进制数        二进制等价数
        0               0                0               0000
        1               1                1               0001
        2               2                2               0010
        3               3                3               0011
        4               4                4               0100   
        5               5                5               0101   
        6               6                6               0110
        7               7                7               0111
        8               8                10              1000
        9               9                11              1001   
        10              A                12              1010   
        11              B                13              1011
        12              C                14              1100
        13              D                15              1101
        14              E                16              1110   
        15              F                17              1111
    */
   
    //二进制反码或按位取反 ~      ~(10011010)表达式 (01100101)结果值
    char val = 2;                   //00000010
    unsigned char newVal = ~val;    //11111101
    // 输出 253
    printf("%d\n", newVal);   

    //位与(AND) &  两个操作数都为1结果才为1  (10010011) & (00111101) = (00010001)
    //位与赋值运算符 &=   val &= 0377 与 val = val & 0377等效
    
    //位或(OR) | 两个操作数任意一个为1结果就为1  (10010011) | (00111101) = (10111111)
    //位或赋值运算符 |=   val |= 0377 与 val = val | 0377等效
    
    //位异或 ^  两个操作数中只有一个为1结果才为1  (10010011) ^ (00111101) = (10101110)
    //位异或赋值运算符 ^=   val ^= 0377 与 val = val ^ 0377等效
    
    //左移 <<  将左侧操作数的值向左移动N位(由右侧操作数指定) 然后丢弃左边移出的操作数 并在右边填充0
    //(10001010) << 2 = (00101000) 向左移动2位 第1、2位被丢弃(左边) 末尾填充2个0(右边)
    //左移动赋值运算符 <<=
    
    //右移 >>  将左侧操作数的值向右移动N位(由右侧操作数指定) 然后丢弃右边移出的操作数
    //对于unsigned，使用0填充左边空出的位 对于signed，结果依赖于机器
    //(10001010) >> 2 = (00100010) | (11100010) 对于无符号肯定是(00100010)，有符号根据不同操作系统可能存在不同值
    //左移动赋值运算符 >>= 
    
    //移位运算符能提供快捷、高效(依赖于硬件)对2的幂的乘法和除法
    // number << n  number乘以2的n次幂
    // number >> n  如果number非负，number除以2的n次幂
    // 类似于十进制中移动小数点来乘以或者乘以10
    return 0;
}

//移位运算符用于较大的单位中提取多组比特位
#include <stdio.h>
#define BYTE_MASK 0xff      //对应二进制11111111
int main(int argc, char const *argv[])
{
    unsigned long color = 0x002a162f;   //对应二进制00101010 00010110 00101111
    unsigned char blue, green, red;
    red = color & BYTE_MASK;                    //001010100001011000101111 & 000000000000000011111111 = 00101111
    green = (color >> 8) & BYTE_MASK;           //000000000010101000010110 & 000000000000000011111111 = 00010110
    blue = (color >> 16) & BYTE_MASK;           //000000000000000000101010 & 000000000000000011111111 = 00101010
    printf("%d %d %d\n", red, green, blue);     //输出对应的10进制为47 22 42
    return 0;
}

// 位字段(bit field)是一个signed int 或 unsigned int中一组相邻的位(C99允许_Bool)
#include <stdio.h>
struct bit
{
    unsigned int a: 1;
    unsigned int b: 2;
    unsigned int c: 3;
    unsigned int d: 32;
} prnt;
int main(int argc, char const *argv[])
{
    // prnt.a的取值范围是0-1      1
    // prnt.b的取值范围是0-3      11
    // prnt.c的取值范围是0-8      111
    // 位长度不能超过32，int的最大长度(4字节*8，具体根据操作系统)
    prnt.a = 1;
    prnt.b = 3;
    prnt.c = 7;
    // 输出1 3 7 0 (默认0)
    printf("%d %d %d %d\n", prnt.a, prnt.b, prnt.c, prnt.d);
    return 0;
}

// 字符串累加INT数组
#include <stdio.h>
#define ARR_SIZE 5
#define TEL_SIZE 11
int main(int argc, char const *argv[])
{
    int arr[ARR_SIZE] = {8, 2, 1, 0, 3};
    int index[TEL_SIZE] = {2, 0, 3, 2, 4, 0, 1, 3, 2, 3, 3};
    char tel[TEL_SIZE + 1];
    int i;
    for (i = 0; i < TEL_SIZE; ++i)
    {
        // + '0'可以将int转为char
        tel[i] = arr[index[i]] + '0';
    }
    // 结尾勿忘累加'\0'
    tel[TEL_SIZE] = '\0';
    puts(tel);
    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

// 运算符 ~ & | ^ >> << &= |= ^= >>= <<=

// 二进制、十进制、十六进制

// 位运算符、位字段

// 字符串累加（int数组合并成字符串）

#include <stdio.h>

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

{

十进制数十六进制数八进制数二进制等价数

0 0 0 0000

1 1 1 0001

2 2 2 0010

3 3 3 0011

4 4 4 0100

5 5 5 0101

6 6 6 0110

7 7 7 0111

8 8 10 1000

9 9 11 1001

10 A 12 1010

11 B 13 1011

12 C 14 1100

13 D 15 1101

14 E 16 1110

15 F 17 1111

//二进制反码或按位取反 ~ ~(10011010)表达式 (01100101)结果值

char val = 2; //00000010

unsigned char newVal = ~val; //11111101

// 输出 253

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

//位与(AND) & 两个操作数都为1结果才为1 (10010011) & (00111101) = (00010001)

//位与赋值运算符 &= val &= 0377 与 val = val & 0377等效

//位或(OR) | 两个操作数任意一个为1结果就为1 (10010011) | (00111101) = (10111111)

//位或赋值运算符 |= val |= 0377 与 val = val | 0377等效

//位异或 ^ 两个操作数中只有一个为1结果才为1 (10010011) ^ (00111101) = (10101110)

//位异或赋值运算符 ^= val ^= 0377 与 val = val ^ 0377等效

//左移 << 将左侧操作数的值向左移动N位(由右侧操作数指定) 然后丢弃左边移出的操作数并在右边填充0

//(10001010) << 2 = (00101000) 向左移动2位第1、2位被丢弃(左边) 末尾填充2个0(右边)

//左移动赋值运算符 <<=

//右移 >> 将左侧操作数的值向右移动N位(由右侧操作数指定) 然后丢弃右边移出的操作数

//对于unsigned，使用0填充左边空出的位对于signed，结果依赖于机器

//(10001010) >> 2 = (00100010) | (11100010) 对于无符号肯定是(00100010)，有符号根据不同操作系统可能存在不同值

//左移动赋值运算符 >>=

//移位运算符能提供快捷、高效(依赖于硬件)对2的幂的乘法和除法

// number << n number乘以2的n次幂

// number >> n 如果number非负，number除以2的n次幂

// 类似于十进制中移动小数点来乘以或者乘以10

return 0;

}

//移位运算符用于较大的单位中提取多组比特位

#include <stdio.h>

#define BYTE_MASK 0xff //对应二进制11111111

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

{

unsigned long color = 0x002a162f; //对应二进制00101010 00010110 00101111

unsigned char blue, green, red;

red = color & BYTE_MASK; //001010100001011000101111 & 000000000000000011111111 = 00101111

green = (color >> 8) & BYTE_MASK; //000000000010101000010110 & 000000000000000011111111 = 00010110

blue = (color >> 16) & BYTE_MASK; //000000000000000000101010 & 000000000000000011111111 = 00101010

printf("%d %d %d\n", red, green, blue); //输出对应的10进制为47 22 42

return 0;

}

// 位字段(bit field)是一个signed int 或 unsigned int中一组相邻的位(C99允许_Bool)

#include <stdio.h>

struct bit

{

unsigned int a: 1;

unsigned int b: 2;

unsigned int c: 3;

unsigned int d: 32;

} prnt;

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

{

// prnt.a的取值范围是0-1 1

// prnt.b的取值范围是0-3 11

// prnt.c的取值范围是0-8 111

// 位长度不能超过32，int的最大长度(4字节*8，具体根据操作系统)

prnt.a = 1;

prnt.b = 3;

prnt.c = 7;

// 输出1 3 7 0 (默认0)

printf("%d %d %d %d\n", prnt.a, prnt.b, prnt.c, prnt.d);

return 0;

}

// 字符串累加INT数组

#include <stdio.h>

#define ARR_SIZE 5

#define TEL_SIZE 11

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

{

int arr[ARR_SIZE] = {8, 2, 1, 0, 3};

int index[TEL_SIZE] = {2, 0, 3, 2, 4, 0, 1, 3, 2, 3, 3};

char tel[TEL_SIZE + 1];

int i;

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

{

// + '0'可以将int转为char

tel[i] = arr[index[i]] + '0';

}

// 结尾勿忘累加'\0'

tel[TEL_SIZE] = '\0';

puts(tel);

return 0;

}

基础了解(十六)

在 2016年6月21日2016年6月21日上张贴由 BestLove

//伸缩型数组成员必须是最后一个数组成员
//结构中必须至少有一个其他成员
//伸缩型数组就像普通数组一样被声明，除了它的方括号内是空的
#include <stdio.h>
struct flex
{
    int count;
    double average;
    double scores[];    //伸缩型数组成员
};
int main(int argc, char const *argv[])
{
    // 假设想要用scores表示含有5个double型数值的数组
    struct flex * pf;
    pf = malloc(sizeof(struct flex) + 5 * sizeof(double));
    return 0;
}

//union联合是一个能在同一存储空间(但不同时)存储不同类型数据的数据类型
#include <stdio.h>
union hold {
    int digit;
    double bigfl;
    char letter;
};
int main(int argc, char const *argv[])
{
    //编译器分配足够的空间以保存所描述的可能性的最大描述
    union hold fit;         //hold类型联合变量    最大可能double 8字节(根据操作系统)
    union hold save[10];    //10个联合变量的数组  10个8字节
    union hold * pu;        //指向hold类型变量的指针
    union hold valA;
    valA.letter = 'R';
    union hold valB = valA;                 //把一个联合初始化为另一个联合
    union hold valC = {88};                 //初始化联合的digit成员
    union hold valD = {.bigfl = 118.2};     //指定初始化项目
    fit.digit = 23;         //把23存储在fit中，使用2个字节
    fit.bigfl = 2.0;        //清除23，存储2.0，使用8个字节
    fit.letter = 'h';       //清除2.0，存储'h'，使用1个字节
    return 0;
}

//enum枚举
#include <stdio.h>
enum spectrum {red, orange, yellow, green, blue, violet};
enum spectrum color;
enum levels {low = 100, medium = 500, high = 2000};
enum feline {cat, lynx = 10, puma, tiger};
enum feline animal;
int main(int argc, char const *argv[])
{
    color = blue;
    // 输出4   默认：0,1,2,3,4,5
    printf("%d\n", color);
    enum levels level;
    level = low;
    // 输出100
    printf("%d\n", level);
    animal = puma;
    // 输出11
    printf("%d\n", animal);
    return 0;
}

// namespace命名空间
#include <stdio.h>
// 结构标记、联合标记、枚举标记和普通变量的命名空间是不同的
// 所以在C中可以定义如下2个rect不会冲突，但是不要这么做
// 1.相同名字容易造成混乱  2.C++中不允许这么做
struct rect
{
    double x;
    double y;
};
int rect;
int main(int argc, char const *argv[])
{
    return 0;
}

// typedef工具是一个高级数据特性，它使你能够为某一类型创建自己的名字
// 在这个方面，它和#define相似，但是它们具有3个不同之处
// 与#define不同，typedef给出的符号名称仅限于对类型，而不是对值
// typedef的解释由编译器，而不是预处理器执行
// 虽然它的范围有限，但在其受限范围内，typedef比#define更灵活
#include <stdio.h>
int main(int argc, char const *argv[])
{
    // 自定义变量名BYTE(通常是大写)表示一个字符
    typedef unsigned char BYTE;
    // 为一个已经存在的类型创建一个名字可能看起来没什么必要，然而这可能是有用的
    // 比如time()的返回值是time_t类型，C标准规范应返回整数类型
    // 但它留给具体的实现来决定到底是哪种整数类型
    time_t time(time_t *);
    // 在一个系统上time_t可能是unsigned int，在另外个系统上可能是unsigned long
    // 只要包含了time.h头文件，程序就可以访问适当的定义
    // 使用#define可以实现typedef的一部分功能
    #define BYTE unsigned char
    // 但也有#define实现不了的功能
    typedef char * STRING;
    STRING name,sign;       //意思是 char * name, * sign;
    // 但如果这么做
    #define STRING char *
    STRING name, sign;      //将会被翻译成char * name, sign;
    // 可以对结构使用typedef
    typedef struct complex      //使用typedef来命名一个结构是，结构的标记可以省去(complex可以不写)
    {
        float real;
        float imag;
    } COMPLEX;
    COMPLEX c1;
    // 把FRPTC声明为一个函数类型，返回一个指向含有5个元素的char数组的指针
    typedef char(* FRPTC())[5];
    return 0;
}

// [] () * 优先级、函数指针
#include <stdio.h>
int main(int argc, char const *argv[])
{
    //[] () 具有相同的优先级(从左到右进行结合)，高于 * 的优先级
    int * risks[10];        //risks是一个指针数组(10个指针)
    int goods[12][50];      //12个具有50个int值的数组构成的数组
    int (* rusks)[10];      //rusks是一个指向具有10个int值的数组的指针(1个指针)
    int * off[3][4];        //3个由4个指向int指针的数组构成的数组(12个指针)
    int (*uuf)[3][4];       //指向3x4的int数组的指针(1个指针)
    char * fump();          //返回指向char指针的函数
    char (* frump)();       //指向返回char类型的函数的指针
    char (* flump[3])();    //由3个指针组成的数组，每个指针指向返回char类型的函数

    typedef int arr5[5];
    typedef arr5 * p_arr5;
    typedef p_arr5 arrp10[10];
    arr5 togs;      //togs是一个由5个int组成的数组
    p_arr5 p2;      //p2是一个指向5个int组成的数组的指针
    arrp10 ap;      //ap是一个10个元素的指针数组，每个指针指向5个int组成的数组
    // 指向函数的指针 要指出函数的返回类型和函数的参量类型
    void ToUpper(char *);
    void ToLower(char *);
    int round(double);
    void (*pf) (char *);    //pf是一个指向函数的指针 (char*)是函数的参量列表 void是返回类型
    pf = ToLower;           //合法，ToUpper是函数ToUpper()的地址
    pf = ToLower;           //合法，ToLower是函数ToLower()的地址
    pf = round;             //不合法，round是错误类型的函数
    pf = ToLower();         //不合法，ToLower()不是地址
    // 调用 语法1和语法2都可以
    char mis[] = "Nina Metier";
    (*pf)(mis);             //语法1 (*pf)就是pf指向的函数
    pf(mis);                //语法2 pf就是函数名
    // 将函数指针作为另一个函数的参数
    void show(void (*fp)(char *), char * str);
    show(ToLower, mis);         //可以传函数名，fp=ToLower
    show(pf, mis);              //可以传函数指针，fp=pf
    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

//伸缩型数组成员必须是最后一个数组成员

//结构中必须至少有一个其他成员

//伸缩型数组就像普通数组一样被声明，除了它的方括号内是空的

#include <stdio.h>

struct flex

{

int count;

double average;

double scores[]; //伸缩型数组成员

};

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

{

// 假设想要用scores表示含有5个double型数值的数组

struct flex * pf;

pf = malloc(sizeof(struct flex) + 5 * sizeof(double));

return 0;

}

//union联合是一个能在同一存储空间(但不同时)存储不同类型数据的数据类型

#include <stdio.h>

union hold {

int digit;

double bigfl;

char letter;

};

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

{

//编译器分配足够的空间以保存所描述的可能性的最大描述

union hold fit; //hold类型联合变量最大可能double 8字节(根据操作系统)

union hold save[10]; //10个联合变量的数组 10个8字节

union hold * pu; //指向hold类型变量的指针

union hold valA;

valA.letter = 'R';

union hold valB = valA; //把一个联合初始化为另一个联合

union hold valC = {88}; //初始化联合的digit成员

union hold valD = {.bigfl = 118.2}; //指定初始化项目

fit.digit = 23; //把23存储在fit中，使用2个字节

fit.bigfl = 2.0; //清除23，存储2.0，使用8个字节

fit.letter = 'h'; //清除2.0，存储'h'，使用1个字节

return 0;

}

//enum枚举

#include <stdio.h>

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

enum spectrum color;

enum levels {low = 100, medium = 500, high = 2000};

enum feline {cat, lynx = 10, puma, tiger};

enum feline animal;

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

{

color = blue;

// 输出4 默认：0,1,2,3,4,5

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

enum levels level;

level = low;

// 输出100

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

animal = puma;

// 输出11

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

return 0;

}

// namespace命名空间

#include <stdio.h>

// 结构标记、联合标记、枚举标记和普通变量的命名空间是不同的

// 所以在C中可以定义如下2个rect不会冲突，但是不要这么做

// 1.相同名字容易造成混乱 2.C++中不允许这么做

struct rect

{

double x;

double y;

};

int rect;

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

{

return 0;

}

// typedef工具是一个高级数据特性，它使你能够为某一类型创建自己的名字

// 在这个方面，它和#define相似，但是它们具有3个不同之处

// 与#define不同，typedef给出的符号名称仅限于对类型，而不是对值

// typedef的解释由编译器，而不是预处理器执行

// 虽然它的范围有限，但在其受限范围内，typedef比#define更灵活

#include <stdio.h>

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

{

// 自定义变量名BYTE(通常是大写)表示一个字符

typedef unsigned char BYTE;

// 为一个已经存在的类型创建一个名字可能看起来没什么必要，然而这可能是有用的

// 比如time()的返回值是time_t类型，C标准规范应返回整数类型

// 但它留给具体的实现来决定到底是哪种整数类型

time_t time(time_t *);

// 在一个系统上time_t可能是unsigned int，在另外个系统上可能是unsigned long

// 只要包含了time.h头文件，程序就可以访问适当的定义

// 使用#define可以实现typedef的一部分功能

#define BYTE unsigned char

// 但也有#define实现不了的功能

typedef char * STRING;

STRING name,sign; //意思是 char * name, * sign;

// 但如果这么做

#define STRING char *

STRING name, sign; //将会被翻译成char * name, sign;

// 可以对结构使用typedef

typedef struct complex //使用typedef来命名一个结构是，结构的标记可以省去(complex可以不写)

{

float real;

float imag;

} COMPLEX;

COMPLEX c1;

// 把FRPTC声明为一个函数类型，返回一个指向含有5个元素的char数组的指针

typedef char(* FRPTC())[5];

return 0;

}

// [] () * 优先级、函数指针

#include <stdio.h>

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

{

//[] () 具有相同的优先级(从左到右进行结合)，高于 * 的优先级

int * risks[10]; //risks是一个指针数组(10个指针)

int goods[12][50]; //12个具有50个int值的数组构成的数组

int (* rusks)[10]; //rusks是一个指向具有10个int值的数组的指针(1个指针)

int * off[3][4]; //3个由4个指向int指针的数组构成的数组(12个指针)

int (*uuf)[3][4]; //指向3x4的int数组的指针(1个指针)

char * fump(); //返回指向char指针的函数

char (* frump)(); //指向返回char类型的函数的指针

char (* flump[3])(); //由3个指针组成的数组，每个指针指向返回char类型的函数

typedef int arr5[5];

typedef arr5 * p_arr5;

typedef p_arr5 arrp10[10];

arr5 togs; //togs是一个由5个int组成的数组

p_arr5 p2; //p2是一个指向5个int组成的数组的指针

arrp10 ap; //ap是一个10个元素的指针数组，每个指针指向5个int组成的数组

// 指向函数的指针要指出函数的返回类型和函数的参量类型

void ToUpper(char *);

void ToLower(char *);

int round(double);

void (*pf) (char *); //pf是一个指向函数的指针 (char*)是函数的参量列表 void是返回类型

pf = ToLower; //合法，ToUpper是函数ToUpper()的地址

pf = ToLower; //合法，ToLower是函数ToLower()的地址

pf = round; //不合法，round是错误类型的函数

pf = ToLower(); //不合法，ToLower()不是地址

// 调用语法1和语法2都可以

char mis[] = "Nina Metier";

(*pf)(mis); //语法1 (*pf)就是pf指向的函数

pf(mis); //语法2 pf就是函数名

// 将函数指针作为另一个函数的参数

void show(void (*fp)(char *), char * str);

show(ToLower, mis); //可以传函数名，fp=ToLower

show(pf, mis); //可以传函数指针，fp=pf

return 0;

}

唐晓锋–BLOG

This is just a personal note.

月份：2016年6月

抽象数据类型ADT(abstract data type)、链表、列表

基础了解(二十)

基础了解(十九)

基础了解(十八)

基础了解(十七)

基础了解(十六)