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

link之家

链接快照平台

输入网页链接，自动生成快照
标签化管理网页链接

相关文章推荐

骑白马的领带 · 解密美国电子阅读发展：09年电子书销量增17 ...· 4 月前 ·

迷茫的皮带 · 我的九寨歌词_百度知道· 5 月前 ·

爱运动的南瓜 · 爱国科学家的典范——纪念“两弹元勋”邓稼先同 ...· 6 月前 ·

行走的冲锋衣 · 2月新剧来袭，袁泉搭档雷佳音，宋佳PK袁咏仪 ...· 7 月前 ·

逃课的风衣 · 【2014款中兴旗舰】汽车中兴旗舰汽车_中兴 ...· 1 年前 ·

腾讯云

备案控制台

开发者社区

TVP

文章/答案/技术大牛

写文章

专栏首页懂点编程的数据分析师 [基础]《C Primer》笔记（上篇）

4 0

分享

#include<stdio.h>
int main(void)
    int i;
    i = 2147483647;
    printf("%d %d %d\n", i, i+1, i+2);
    unsigned int j;
    j = 4294967295;
    printf("%u %u %u\n", j, j+1, j+2);
}

2147483647 -2147483648 -2147483647
4294967295 0 1

char grade = 'A';

float some;
some = 4.0 * 2.0；

#include<stdio.h>
int main(void)
    float toobig = 3.4e38 * 10.0f;
    printf("%f %e\n", toobig, toobig);     
}

inf inf

#include<stdio.h>
int main(void)
    float a, b;
    b = 2.0e20 + 1.0;
    a = b - 2.0e20;
    printf("%f\n", a);
}

#include<stdio.h>
int main(void)
    printf("Type int has a size of %zd bytes.\n", sizeof(int));
    printf("Type char has a size of %zd bytes.\n", sizeof(char));
    printf("Type double has a size of %zd bytes.\n", sizeof(double));
    printf("Type long has a size of %zd bytes.\n", sizeof(long));
    printf("Type long long has a size of %zd bytes.\n", sizeof(long long));
    printf("Type long double has a sizeof %zd bytes.\n", sizeof(long double));
}

Type int has a size of 4 bytes.
Type char has a size of 1 bytes.
Type double has a size of 8 bytes.
Type long has a size of 8 bytes.
Type long long has a size of 8 bytes.
Type long double has a sizeof 16 bytes.

#define TAXRATE 0.015

#define BEEP '\a'
#define TEE 'T'
#define ESC '\033'
#define OOPS "Now you have done it!"

#define INT_MAX +32767
#define INT_MIN -32768

修饰符	含义
标记	包含-、+、#、空格和0五种标记，可以不使用或使用多个
数字	最小字段宽度
.数字	精度
h	和整型转换说明一起使用，表示short int或unsigned short int
hh	表示signed char或unsigned char
j	表示intmax_t或uintmax_t
l	表示long int或unsigned long int
ll	表示long long int或unsigned long long int
L	表示long double
t	表示ptrdiff_t
z	表示size_t

标记	含义
-	待打印项左对齐，配合宽度一起使用
+	有符号值若为正，则在值前面显示+号，如果为负，则显示-号
空格	有符号值若为正，则在值前面显示前导空格（不显示任何符号）；若为负，则在值前面显示-号
#	把结果转换为另一种形式
0	对于数值格式，用前导0代替空格填充字段宽度。对于整数格式，如果出现-标记或者指定精度，则忽略该标记

#include<stdio.h>
#define PAGES 959
int main(void)
    printf("*%d*\n", PAGES);
    //由于限制的宽度2小于PAGES本身长度，所以相当于不做限制
    printf("*%2d*\n", PAGES);
    printf("*%10d*\n", PAGES);
    printf("%-10d*\n", PAGES);
    return 0;
}

*959*
*959*
*       959*
959       *

#include<stdio.h>
int main(void)
    const double RENT = 3852.99;
    printf("*%f*\n", RENT);
    printf("*%e*\n", RENT);
    printf("*%4.2f*\n", RENT);
    printf("*%3.1f*\n", RENT);
    printf("*%10.3f*\n", RENT);
    printf("*%10.3E*\n", RENT);
    printf("*%+4.2f*\n", RENT);
    printf("*%010.2f*\n", RENT);
    return 0;
}

*3852.990000*
*3.852990e+03*
*3852.99*
*3853.0*
*  3852.990*
* 3.853E+03*
*+3852.99*
*0003852.99*

while (expression)
    statement

while (scanf("%d", &num) == 1)
    ; /* 跳过整数输入 */

for (n = 0; n < 10; n++)
    statement;

#include<stdio.h>
int main(void)
    const int FIRST_OZ = 46;
    const int NEXT_OZ = 20;
    int ounces, cost;
    printf("ounces cost \n");
    for(ounces = 1, cost = FIRST_OZ; ounces <= 16; ounces++, cost += NEXT_OZ)
        printf("%5d   $%4.2f\n", ounces, cost / 100.0);
    return 0;
}

ounces cost 
    1   $0.46
    2   $0.66
    3   $0.86
    4   $1.06
    5   $1.26
    6   $1.46
    7   $1.66
    8   $1.86
    9   $2.06
   10   $2.26
   11   $2.46
   12   $2.66
   13   $2.86
   14   $3.06
   15   $3.26
   16   $3.46

#include<stdio.h>
#define ROWS 6
#define CHARS 10
int main(void)
    int row;
    char ch;
    for (row = 0; row < ROWS; row++) /* 输出ROWS行 */
        for (ch = 'A'; ch < ('A' + CHARS); ch++)
            printf("%c", ch); /* 每一行输出CHARS个字符 */
        printf("\n");
}

ABCDEFGHIJ
ABCDEFGHIJ
ABCDEFGHIJ
ABCDEFGHIJ
ABCDEFGHIJ
ABCDEFGHIJ

#include<stdio.h>
int main(void)
    const int ROWS = 6;
    const int CHARS = 6;
    int row;
    char ch;
    for (row = 0; row < ROWS; row++) /* 输出ROWS行 */
        for (ch = ('A' + row); ch < ('A' + CHARS); ch++)
            printf("%c", ch); /* 每一行输出CHARS个字符 */
        printf("\n");
}

ABCDEF
BCDEF
F

float debts[20];

debts[5] = 88.32

switch (expression)
    case label1: statement1 //使用break跳出switch
    case label2: statement2
    default: statement3
}

while (expression)
    for (i=1; i<=100; i++)
        for(j=1; j<=100; j++)
            if (问题)
                goto help;
help: 语句

#include<stdio.h>
#define STOP '#'
int main(void)
    char ch;
    while ((ch = getchar()) != STOP)
        putchar(ch);
    return 0;
}

这是第一行输入
这是第一行输入
下面输入空格行
下面输入空格行
最后一行正常输入
最后一行正常输入
带井号的输入
带井号的输入
这是一行带#号的输入
这是一行带%

HHeelllloo,,  tthheerree .. II  ww[enter]
lliikkee aa  #

#include<stdio.h>
int main(void)
    char ch;
    while ((ch = getchar()) != EOF)
        putchar(ch);
    return 0;
}

#include<stdio.h>
void to_binary(unsigned long n);
int main(void)
    int num = 0;
    printf("please input a number: \n");
    scanf("%d", &num);
    to_binary(num);
    return 0;
void to_binary(unsigned long n) /* 递归函数 */
    int r;
    r = n % 2;
    if (n >= 2)
        to_binary(n/2);
    putchar(r == 0 ? '0' : '1');
}

#include<stdio.h>
unsigned long Fibonacci(unsigned n);
int main(void)
    unsigned num = 0;
    printf("please input a number: \n");
    scanf("%d", &num);
    unsigned long result = Fibonacci(num);
    printf("the result is: %ld\n", result);
    return 0;
unsigned long Fibonacci(unsigned n)
    // 双递归
    if (n > 2)
        return Fibonacci(n-1) + Fibonacci(n-2);
        return 1;
}

float candy[365];
char code[12];
int states[50];

int powers[8] = {1,2,4,6,8,16,32,64}

#define MONTHS 12
int days[MONTHS] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

const int days[MONTHS] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

const int days[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
for (index = 0; index < sizeof days / sizeof days[0]; index++)
    printf("Month %2d has %d days.\n", index + 1, days[index]);
return 0;

days[1] = 31

#define SIZE 4
int main(void) 
    int arr[SIZE];
    for (i = 0; i < SIZE; i++)
}

float rain[5][12]
// 表示rain是一个内含5个元素的数组，每个元素是一个内含12个float元素的数组，即rain中每个元素的类型是float[12]

/* rain.c --计算每年的总降水量、年平均降水量和5年终每个月的平均降水量 */
#include <stdio.h>
#define MONTHS 12
#define YEARS 5
int main(void)
    // 用2010年~2014年的降水量初始化二维数组
    const float rain[YEARS][MONTHS] = 
        {4.3, 4.3, 4.3, 3.0, 2.0, 1.2, 0.2, 0.2, 0.4, 2.4, 3.5, 6.6},
        {9.5, 8.2, 1.2, 1.6, 2.4, 0.0, 5.2, 0.9, 0.3, 0.9, 1.4, 7.3},
        {9.1, 8.5, 6.7, 4.3, 2.1, 0.8, 0.2, 0.2, 1.1, 2.3, 6.1, 8.4},
        {7.2, 9.9, 8.4, 3.3, 1.2, 0.8, 0.4, 0.0, 0.6, 1.7, 4.3, 6.2},
        {7.6, 5.6, 3.8, 2.8, 3.8, 0.2, 0.0, 0.0, 0.0, 1.3, 2.6, 5.2}
    int year, month;
    float subtot, total;
    printf("  YEAR   RAINFALL(inches)\n");
    for (year = 0, total = 0 ; year < YEARS; year ++)
        for (month = 0, subtot = 0; month < MONTHS; month++)
            subtot += rain[year][month];
        printf("%5d %15.1f\n", 200 + year, subtot);
        total += subtot; // 5年的总降水量
    printf("\nThe yearly average is %.1f inches.\n\n", total / YEARS);
    printf("MONTHLY AVERAGE:\n\n");
    printf(" Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec \n");
    for (month = 0; month < MONTHS; month++)
        for (year = 0, subtot = 0; year < YEARS; year++)
            subtot += rain[year][month];
        printf("%4.1f", subtot / YEARS);
    printf("\n");
    return 0;
}

 YEAR   RAINFALL(inches)
  200            32.4
  201            38.9
  202            49.8
  203            44.0
  204            32.9
The yearly average is 39.6 inches.
MONTHLY AVERAGE:
 Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec 
 7.5 7.3 4.9 3.0 2.3 0.6 1.2 0.3 0.5 1.7 3.6 6.7

const float rain[YEARS][MONTHS] = 
    {4.3, 4.3, 4.3, 3.0, 2.0, 1.2, 0.2, 0.2, 0.4, 2.4, 3.5, 6.6},
    {9.5, 8.2, 1.2, 1.6, 2.4, 0.0, 5.2, 0.9, 0.3, 0.9, 1.4, 7.3},
    {9.1, 8.5, 6.7, 4.3, 2.1, 0.8, 0.2, 0.2, 1.1, 2.3, 6.1, 8.4},
    {7.2, 9.9, 8.4, 3.3, 1.2, 0.8, 0.4, 0.0, 0.6, 1.7, 4.3, 6.2},
    {7.6, 5.6, 3.8, 2.8, 3.8, 0.2, 0.0, 0.0, 0.0, 1.3, 2.6, 5.2}
};

int box[10][20][30]

flizny == &flizny[0];

dates + 2 == &dates[2]   //相同地址
*(dates + 2) == dates[2] //相同值

int sum(int * ar)  
    int i;
    int total = 0;
    for (i=0; i<10; i++)
        total += ar[i];
    return total;
}

int sum(int * ar, int n)
    int i;
    int total = 0;
    for (i = 0; i < n; i++)
        total += ar[i];
    return total;
}

int sum(int ar[], int n);

int sump(int * start, int * end)
    int total = 0;
    while (start < end)
        total += *start;
        start++;
    return total;
}

answer = sump(marbles, marbles + SIZE);

int sum(const int ar[], int n); /* 函数原型 */
int sum(const int ar[], int n); /* 函数定义*/
    int i;
    int total = 0;
    for (i = 0; i < n; i++)
        total += ar[i];
    return total;
}

#define MONTH 12
const int days[MONTHS] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}

double rates[5] = {88.99, 100.12, 59.45, 183.11, 340.5};
const double * pd = rates;
*pd = 29.89;      //不允许
pd[2] = 222.22;   //不允许
rates[0] = 99.99; //允许，因为rates并非被cosnt限定
pd++;             //允许，可以改变指针值

// 构造普通数组和const数组
double rates[5] = {88.99, 100.12, 59.45, 183.11, 340.5};
const double locked[4] = {0.08, 0.075, 0.0725, 0.07};
// 构造指向const的指针，即我们不能通过指针修改数组
const double *pc = rates; //有效
pc = locked;              //有效
pc = &rates[3];           //有效

// 构造普通数组和const数组
double rates[5] = {88.99, 100.12, 59.45, 183.11, 340.5};
const double * pd = rates;
double * pnc = rates; //有效，指向非const数组
pnc = lockedl         //无效，普通指针不能指向const数组
pnc = &rates[3];      //有效

int (* pz)[2];

int * pax[2] // pax是内含两个指针元素的数组，每个元素都是指向int的指针

/* rain.c --计算每年的总降水量、年平均降水量和5年终每个月的平均降水量 */
#include <stdio.h>
#define ROWS 3
#define COLS 4
void sum_rows(int ar[][COLS], int rows);
void sum_cols(int [][COLS], int);    // 省略参数名
int sum2d(int(*ar)[COLS], int rows); // 另一种表示二维数组的方法
int main(void)
    int junk[ROWS][COLS] = {
        { 2, 4, 6, 8 },
        { 3, 5, 7, 9 },
        { 12, 10, 8, 6 }
    sum_rows(junk, ROWS);
    sum_cols(junk, ROWS);
    printf("Sum of all elements = %d\n", sum2d(junk, ROWS));
    return 0;
void sum_rows(int ar[][COLS], int rows)
    int r;
    int c;
    int tot;
    for (r = 0; r < rows; r++)
        tot = 0;
        for (c = 0; c < COLS; c++)
            tot += ar[r][c];
        printf("row %d: sum = %d\n", r, tot);
void sum_cols(int ar[][COLS], int rows)
    int r; 
    int c;
    int tot;
    for (c = 0; c < COLS; c++)
        tot = 0;
        for (r = 0; r < rows; r++)
            tot += ar[r][c];
        printf("col %d: sum = %d\n", c, tot);
int sum2d(int ar[][COLS], int rows)
    int r;
    int c;
    int tot = 0;
    for (r = 0; r < rows; r++)
        for (c = 0; c < COLS; c++)
            tot += ar[r][c];
    return tot;
}

row 0: sum = 20
row 1: sum = 24
row 2: sum = 36
col 0: sum = 17
col 1: sum = 19
col 2: sum = 21
col 3: sum = 23
Sum of all elements = 80

int quarters = 4;
int regions = 5;
doible sales[regions][quarters]; //一个变长数组（VLA）

// 普通数组
int diva[2] = {10, 20};
// 复合字面量的匿名数组
(int [2]){10, 20};

#include <stdio.h>
#define MSG "I am a symbolic string constant."
#define MAXLENGTH 81
int main(void)
    char words[MAXLENGTH] = "I am a string in an array.";
    const char * pt1 = "Something is pointing at me.";
    puts("Here are some strings:");
    puts(MSG);
    puts(words);
    puts(pt1);
    words[8] = 'p';
    puts(words);
    return 0;
}

Here are some strings:
I am a symbolic string constant.
I am a string in an array.
Something is pointing at me.
I am a spring in an array.

const char m1[40] = "Limit yourself to one line's worth.";
// 下面是等价的但是麻烦的标准数组初始化
const char m1[40] = {
  'L', 'i', 'm', 'i', 't', ' ', 'y', 'o', 'u', 'r', 's', 'e', 'l', 'f',
  ' ', 't', 'o', ' ', 'o', 'n', 'e', ' ', 'l', 'i', 'n', 'e', '\'', 's', 
  ' ', 'w', 'o', 'r', 't', 'h', '.', '\0'
// 如果没有最后的空字符串，那么这就不是一个字符串而是一个字符数组。
// 在指定数组大小时，需要确保数组的元素至少比字符串长度多1（为了容纳最后的空字符），所有未被使用的元素都被自动初始化为\0

const char * pt1 = "Something is pointing at me.";

const char ar1[] = "Something is pointing at me.";

/* addresses.c --字符串地址 */
#include <stdio.h>
#define MSG "I'm special"
int main(void)
    char ar[] = MSG;
    const char * pt = MSG;
    printf("address of \"I'm special\": %p \n", "I'm special");
    printf("              address ar: %p\n", ar);
    printf("              address pt: %p\n", pt);
    printf("          address of MSG: %p\n", MSG);
    printf("address of \"I'm special\": %p \n", "I'm special");
    return 0;
}
address of "I'm special": 0x10b505f30 
              address ar: 0x7fff546faa7c
              address pt: 0x10b505f30
          address of MSG: 0x10b505f30
address of "I'm special": 0x10b505f30 
char heart[] = "I love Tillie!";
const char *head = "I love Millie";
const char *mytalents[5] = {
    "Adding numbers swiftly",
    "Multiplying accurately", 
    "Stashing data".
    "Following instructions to the letter",
    "Understanding the C language"
};
char yourtalents[5][40] = {
    "Walking in a staight line",
    "Sleeping",
    "Watching television",
    "Mailing letters",
    "Reading email"
};

Don't be a fool!
mesg = Don't be a fool!; &mesg = 0x7fff55dc6a88; value = 0x109e39f56
copy = Don't be a fool!; &copy = 0x7fff55dc6a80; value = 0x109e39f56

// 正确的做法
char name[81];
// 错误的做法
// 虽然可能通过编译，但是在读入name时可能会擦写掉程序中的数据或者代码
char *name;
scanf("%s", name);

pts2 = pts1;

/* sort_str.c --读入字符串，并排序字符串 */
#include <stdio.h>
#include <string.h>
#define SIZE 81 /*限制字符串长度，包括\0*/
#define LIM 20  /*可读入的最多行数*/
#define HALT "" /*空字符串停止输入*/
void stsrt(char *strings [], int num);   /*字符串排序函数*/
char * s_gets(char * st, int n);
int main(void)
    char input[LIM][SIZE];     /*储存输入的数组*/
    char *ptstr[LIM];          /*内含字符指针的数组*/
    int ct = 0;                /*输入计数*/
    int k;                     /*输出计数*/
    printf("Input up to %d lines, and I will sort them.\n", LIM);
    printf("To stop, press the Enter key at a line's start.\n");
    while (ct < LIM && s_gets(input[ct], SIZE) != NULL
            && input[ct][0] != '\0')
        ptstr[ct] = input[ct]; /*设置指针指向字符串*/
        ct++;
    stsrt(ptstr, ct);          /*字符串排序函数*/
    puts("\nHere's the sorted list:\n");
    for(k = 0; k < ct; k++)
        puts(ptstr[k]);        /*排序之后的指针*/
    return 0;
/* 字符串-指针-排序函数 */
void stsrt(char *strings [], int num)
    char *temp;
    int top, seek;
    for (top = 0; top < num - 1; top++)
        for (seek = top + 1; seek < num; seek++)
            if (strcmp(strings[top], strings[seek]) > 0)
                    temp = strings[top];
                    strings[top] = strings[seek];
                    strings[seek] = temp;
char * s_gets(char * st, int n)
    char * ret_val;
    int i = 0;
    ret_val = fgets(st, n, stdin);
    if (ret_val)
        while (st[i] != '\n' && st[i] != '\0')
        if (st[i] == '\n')
            st[i] = '\0';
            while (getchar() != '\n')
                continue;
    return ret_val;
}

Input up to 20 lines, and I will sort them.
To stop, press the Enter key at a line's start.
O that I was where I would be,
Then would I be where I am not;
But where I am I must be,
And where I would be I can not.
Here's the sorted list:
And where I would be I can not.
But where I am I must be,
O that I was where I would be,
Then would I be where I am not;

find = strchr(line, '\n');
if (find)  // 如果地址不是NULL, 用空字符串替换
    *find = '\0';

// nptr是指向待转换字符串的指针，endptr是一个指针的地址，被设置为标识输入数字结束字符的地址
// base表示以什么进制写入数字
# 第十二章 存储类别、链接和内存管理
## 存储类别`storage class`
* 对象：从硬件的角度，被存储的每一个值都占用一定的物理内存，C语言把这样的一块内存称之为对象`object`
* 标识符：标识符`identifier`是一个名称，指定特定对象的内容
* 左值：==指定对象的表达式被称之为左值==
int entity = 3;
int * pt = &entity;
int ranks[10];

int giants = 5;          // 外部链接
static int dodgers = 3;  // 内部链接

void bore(int number)
    int index;
    for (index = 0; index < number; index++)
        puts("They don't make them the way they used to.\n");
    return 0;
}

void more(int number)
    int index;
    static int ct = 0;
    return 0;
}

存储类别	存储期	作用域	链接	声明方式
自动	自动	块	无	块内
寄存器	自动	块	无	块内，使用关键字register
静态外部链接	静态	文件	外部	所有函数外
静态内部链接	静态	文件	内部	所有函数外，使用关键字static
静态无链接	静态	块	无	块内，使用关键字static

// tents变量被初始化为5
// repid变量的值时之前占用分配给`repid`的空间中的任意值，别指望它是0
int main(void)
    int repid;
    int tents = 5;
}

int Errupt;         /* 外部定义的变量 */
extern char Coal;  /* 如果Coal被定义在另一个文件中， 则必须这么声明 */

int tern = 1; /* tern被定义 */
main()
    extern int tern;  /* 使用在别处定义的tern */
}

static int svil = 1;    // 静态变量，内部链接
int main(void)
}

int traveler = 1;    // 外部链接
static int stayhome = 1; // 内部链接
int main()
    extern int traveler;   // 使用定义在别处的traceler
    extern int stayhome;   // 使用定义在别处的 stayhome
}

double gamma(double);     // 该函数默认为外部函数
static double beta(int, int);
extern double delta(double, int);

/* s_and_r.c --包含 rand1() 和 srand1() 的文件 */
static unsigned long int next = 1; /* 种子 */
int rand1(void)
    /*生成随机数的魔术公式*/
    next = next * 1103515245 + 12345;
    return (unsigned int) (next / 65536) % 32768;
void srand1(unsigned int seed)
    next = seed;
}

// 为float类型和字符串预留足够的内存
float x;
char place[] = "Dancing Oeen Creek";
// 显式指定分配一定的内存
// 该声明预留了100个内存位置，每个位置存储int类型
// 并且为内存提供了一个标识符，可以通过`x`或者`place`识别数据
int plates[100];

double * ptd;
ptd = (double *) malloc(30 * sizeof(double));

long * newmem;
newmem = (long *)calloc(100, sizeof(long));

int vlamal()
    int n;
    int * pi;
    scanf("%d", &n);
    pi = (int *) malloc (n * sizeof(int));
    int ar[n]; //变长数组
    pi[2] = ar[2] = -5;
}

int n = 5;
int m = 6;
int ar2[n][m];   // nxm的变长数组（VLA）
int (* p2)[6];   // C99之前的写法，表示指向一个内含6个int类型值的数组，因此p2[i]代表一个由6个整数构成的元素
int (* p3)[m];   // 要求支持变长数组
p2 = (int (*)[6]) malloc(n * 6 * sizeof(int));  // nx6数组
p3 = (int (*)[m]) malloc(n * m * sizeof(int));  // nxm数组（要求支持变长数组）

const float * pf; // pf指向一个float类型的const值，不能修改float的值
float * const pt; // pt是一个const指针，不能修改pt
const float * const pt; // pt本身的值不能修改，它所指向的值也不能修改

/* file1.c --定义一些外部cosnt变量 */
const double PI = 3.14159
const char * MONTHS[12] = {"January", "February", "March", "April", "May",
    "June", "July", "Augest", "September", "Octover", "November", "December"
/* file2.c 00使用定义在别处的const变量 */
# include "constant.h"

/* constant.h --定义了一些外部const变量 */
static const double PI = 3.14159;
static const char * MONTHS[12] = {"January", "February", "March", "April", "May",
    "June", "July", "Augest", "September", "Octover", "November", "December"
/* file1.c --使用定义在别处的外部const变量*/
# include "constant.h"

val1 = x;
/* 一些不使用x的代码 */
val2 = x;

int ar[10];
int * restrict restar = (int *) malloc(10 * sizeof(int))
int * par = ar

for (n = 0; n < 10; n++)
    par[n] += 5;
    restar[n] += 5;
    ar[n] *= 2;
    par[n] += 3;
    restar[n] += 3;
}

restar[n] += 8;

_Atomic int hogs;    // 原子类型的变量
atomic_store(&hogs, 12); // 在hogs中存储12是一个原子过程
long strtol(const char * restrict nptr, char ** restrict endptr, int base);

TOMOCAT

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

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

第三章 数据和C

整数

1.如何选择需要使用的整数类型

2. 和 long long常量

3.注意整数溢出问题

字符类型char

1.字符类型的表示

2.打印字符

布尔类型_Bool

float、double和long double

1.float类型

2.double类型

3.注意事项

4.浮点型的打印

5.浮点型的上溢和下溢

6.浮点型四舍五入的错误

显示类型大小

第四章 字符串与格式化输入输出

字符串简介

1.char类型数组与null字符

2.字符串与字符

3.strlen()函数

常量和C预处理器

1.C语言声明常量

2.定义字符和字符串常量

3.const限定符

4.明示变量

printf()和scanf()

1.printf()函数

2.使用修饰符和标记的例子

3.scanf()函数

4.printf()的用法提示

第五章 运算符、表达式和语句

基本运算符

1.赋值运算符: =

2.加减乘除

3.运算符优先级

其他运算符

表达式

类型转换

1.基本的类型转换规则

2.待赋值的值与目标类型不匹配时

3.强制类型转换运算符

参数：实参与形参

第六章 C控制语句：循环

while循环

1.基本结构

2.循环体可以是空语句

3.C中可以使用 _Bool 类型表示布尔型

不确定循环与计数循环

1.计数循环

for循环

1.格式

2.在for循环中使用逗号

do while出口循环

嵌套循环

1.用于按行和按列显示数据

2.利用外层循环遍历控制内层循环

数组简介

1.数组声明

2.数组赋值

3.字符数组与字符串

else if

循环辅助：continue与break

多重选择：switch和break

1.形式

2.约束

goto语句

第八章 字符输入输出和输入验证

单字符I/O

缓冲区

1.无缓冲输入

2.缓冲输入

3.使用缓冲区的原因

4.缓冲的类别

结束键盘输入

1.文件，流和键盘输入