前语

1. 本文首要阅读《C Programing:A Modern Approch》2th ，中的一些章节，做一些模型结构笔记，便于参看。
2. 本文对内容结构有所合并表述。Github仓库中按章节有更详细的片段代码实践，按需运用。
3. 辅助参看材料包括但不限于如GUN的C文档,和其他网络文档片段。

一、基本内容

1.简略程序一般内容

一个简略的C程序包括：指令，函数，句子，显现，注释

  /*
   * 指令：#include "stdio.h"
   * 函数：int main(){return 0;}
   * 句子：printf("this is a statements\n");
   * 显现：printf("xxx content");
   * 注释：如本段
   * */
#include <stdio.h>
#define PI 3.1415926
int main() {
  printf("this is a C program");
  return 0;
}

2.编译运转程序

预处理->编译->链接
gcc/cc -o <outputfile> <sourcefile> [-w]

预处理：程序交给预处理器，履行#最初的指令
编译：编译器compiler（如：gcc、cc）将程序翻译成机器指令（方针代码）
链接：linker把发生的方针代码和其他附加代码（如一些库函数printf）整合，发生可履行程序

3.变量和赋值

二、格局化输入输出

1. printf函数和scanf函数

#include <stdio.h>
int main(){
    char sign = 'A';
    int age = 18;
    printf("class is-> %c,age is->%d,next age is->%d\n", sign, age, age + 1);
    int a,b;
    printf("input int number a+b:\n");
    scanf("%d+%d",&a,&b);
    printf("scanf value is a=%d b=%d sum=%d\n",a,b,a+b);
}

2. 转化阐明符（Conversion specification）

%[flag][width][.precision]type
flag：+右对齐 -左对齐
width：最小宽度
precision：精度

# The GNU C Library/Output-Conversion-Syntax

常见转化阐明符

C99中%zu输出size_t型,打印sizeof()函数值

3. 转义序列（Escape sequence）

常见转义序列符

三、表达式

算术运算符

最高优先级：+ -（作为一元运算符） * / %
最低优先级：+ -

• 一元运算右结合，二元运算左结合

赋值运算

简略赋值和复合赋值

  int android, java, python,c;
   /*简略赋值*/
  android = 1;
  java = android;
  c = android + java * 10;
  /*复合赋值*/
  c = android = python = java * 10;

      下列表达式：
      a = b += c++ -d + --e / -f
      相当于：
      step1: a = b += (c++) -d + --e / -f
      step2: a = b += (c++) -d + (--e) / (-f)
      step3: a = b += (c++) -d + ((--e) / (-f))
      step4: a = b += (((c++) -d) + ((--e) / (-f)))
      step5: a = (b += (((c++) -d) + ((--e) / (-f))))
      step6: (a = (b += (((c++) -d) + ((--e) / (-f)))))

四、挑选句子

逻辑表达式

1. 联系运算符：>,<,>=,<=
2. 判等运算符：==,!=
3. 逻辑运算符：！（一元），&&，||（二元）

if

if(express) statement
if(expr) stat else stat
if(expr) stat else if(expr) stat else stat

swtich

switch (expr){
  case constant-expr:statements
  ...
  case constant-expr:statements
  default:statements
}

五、循环loops

举例：

#include <stdio.h>
int main() {
  /**
   * 无线循环while(1)
   */
  long long int unLimit = 0;
  while (1) {
	printf("loop while(1) unLimit %lld\n", unLimit++);
	if (unLimit > 99) {
	  goto Label_While_Break;
	}
  }
Label_While_Break:
  printf("this is goto mark while(1) Label\n");
  /**
   * 无限循环for(;;)
   */
  for(;;){
    printf("loop for(;;) unLimit %lld\n", unLimit++);
    if (unLimit > 200) {
	  goto Label_For_Break;
    }
  }
Label_For_Break:
  printf("this is goto mark for(;;) Label\n");
  for(unLimit;unLimit>0;unLimit--){
    printf("this is for decrease, value = %lld\n",unLimit);
  }
  while (unLimit<10){
    printf("this is while(unLimit<10) loop, value = %lld\n",unLimit);
    unLimit++;
  }
  return 0;
}

六、基本类型

数值类型

短整数：前面加上h,如h<d\o\u\x>
长整数：前面加上l,如l<d\o\u\x>

short short_v = 2;
unsigned short int u_short_v = 2;
int int_v = 10;
unsigned int u_int_v =19;
long long_v = 1000;
unsigned long u_long_v=1009;
long long long_long_v = 10000;
unsigned long long u_long_long_v = 10009;
float float_v = 1.3f;
double double_v = 0.2345678901;
long double long_double_v = 0.2345678901;
printf("short=%hd\t sizeof(short)=%zu\n", short_v, sizeof(short));
printf("unsigned short=%hu\t sizeof(unsigned short)=%zu\n", u_short_v, sizeof(unsigned short));
printf("int=%d\t sizeof(int)=%zu\n", int_v, sizeof(int));
printf("unsigned int=%u\t sizeof(unsigned int)=%zu\n", u_int_v, sizeof(unsigned int));
printf("long=%ld\t sizeof(long)=%zu\n", long_v, sizeof(long));
printf("unsigned long=%lu\t sizeof(unsigned long)=%zu\n", u_long_v, sizeof(unsigned long));
printf("long long=%lld\t sizeof(long long)=%zu\n", long_long_v, sizeof(long long));
printf("unsigned long long=%llu\t sizeof(unsigned long long)=%zu\n", u_long_long_v, sizeof(unsigned long long));
printf("float(m.p=0.2) =%0.2f\t sizeof(float)=%zu\n", float_v, sizeof(float));
printf("float(m.p=1.2) =%1.2f\t sizeof(float)=%zu\n", float_v, sizeof(float));
printf("float(m.p=.6) =%.6f\t sizeof(float)=%zu\n", float_v, sizeof(float));
printf("float(m.p=.10) =%.10f\t sizeof(float)=%zu\n", float_v, sizeof(float));
printf("float(m.p=.10) =%.10lf\t sizeof(double)=%zu\n", double_v, sizeof(double));
printf("float(m.p=.6) =%.6lf\t sizeof(double)=%zu\n", double_v, sizeof(double));
printf("float(m.p=.6) =%.6Lf\t sizeof(double)=%zu\n", long_double_v, sizeof(long double));

在我的电脑测验输出为：

short=2  sizeof(short)=2
unsigned short=2         sizeof(unsigned short)=2
int=10   sizeof(int)=4
unsigned int=19  sizeof(unsigned int)=4
long=1000        sizeof(long)=4
unsigned long=1009       sizeof(unsigned long)=4
long long=10000  sizeof(long long)=8
unsigned long long=10009         sizeof(unsigned long long)=8
float(m.p=0.2) =1.30     sizeof(float)=4
float(m.p=1.2) =1.30     sizeof(float)=4
float(m.p=.6) =1.300000  sizeof(float)=4
float(m.p=.10) =1.2999999523     sizeof(float)=4
float(m.p=.10) =0.2345678901     sizeof(double)=8
float(m.p=.6) =0.234568  sizeof(double)=8
float(m.p=.6) =0.000000  sizeof(double)=16

字符类型

输入:scanf("%c",&ch);
输出:printf("%c",ch);

putchar(ch)写入ch中
int ch = getchar()读
获取用户输入更快
不会越过空白字符

惯用法

/*skips rest of line*/
while（getchar()!='\n'）
   ;
/*skip blanks*/
while (getchar() == '  ')
   ;

转巨细写

/**办法一:*/
if（‘a’ <= ch && ch <= 'z'）
    ch =ch-'a'+'A'
/**办法二:*/
#include <ctype.h>
    if（toupper(ch)='A'）

实验程序：

#include <stdio.h>
#include <ctype.h>
int main() {
  /*
   * 2.字符类型char
   * */
  char char_value = 'a';
  printf("char value=%c\n", char_value);
  /**
   * 3.转大写
   */
  if ('a' <= char_value && char_value <= 'z') {
	printf("upper char method normal:%c\n", char_value - 'a' + 'A');
	printf("upper char method(toupper) 2:%c\n", toupper(char_value));
  }
  /**
   * 4.typedef 长处，易了解，修正
   */
  typedef int STATUS;
  STATUS status_a = 100;
  printf("tpyedef status:%d\n", status_a);
  /**
   * 5.读写字符scanf()/printf()
   * 不会越过空白字符
   */
  char scanf_char;
  printf("input a char (by scanf method):\n");
  scanf("%c", &scanf_char);
  printf("out you char value(by printf):%c\t\n", scanf_char);
  while (getchar() != '\n');
  printf("Skip rest of line...\n");
  /**
   * 6.读写字符
   * getChar()/ 读取输入字符，一次只能单字符，不会越过空白字符
   * putChar(ch) 一次只能单字符输出
   *
   */
  printf("\ninput (by getchar() single char ):");
  int get_char = getchar();
  putchar(get_char);
  printf("\n__________________\n");
  printf("output (by getChar()) :%c\n", get_char);
  printf("+++++++++++++++++++++\n");
  printf("++++++input to output++++++\n");
  while ((get_char = getchar()) != EOF) {
	putchar(get_char);
  }
  return 0;
}

类型转化

中间的unsigned 全名为unsigned long 类型

• 假如变量类型至少和表达式类型相同“宽”，在赋值过程中转化:
  char c;int i; float f;double d;
i=c; f=i; d=f;
• 强制转化：
  cast expressing:（type-name）expression

sizeof运算

sizeof expressing: sizeof(type-name)

printf("size of int:%lu\n",(unsigned long) sizeof(int));
printf("size of int:%zu\n", sizeof(int));//c99 only

七、数组

#define N 10
#define M 11
int main(){
    /**
     * 1.一维数组
     * 界说：int a[N];
     * 初始化：int a[10]={1,2,3,4}
     *        或者 a[10]={0}
     * c99: int a[10]={[1]=9,[5]=7};指定方位初始化
     * 一起存在 int a[]={1,2,9,4,[0]=5,8} 输出 {5,8,9,4}
     */
    /**
     * 2.多维数组
     * 界说：int a[M][N];
     * 初始化：int a[M][N] = {{1,2,3},{1,23,4},...};可不全列出
     * C99(可指定方位初始化): int a[2][2] = { [0][1]=1,[1][1]=2};
     */
   /**
    * 3. 常量数组 constant arrays
    * 界说：在数组前面加 const
    */
  const char hex_chars[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
  /**
   ** 4. c99中的变长数组VLA
   * 变长长度不一定用变量来指定，恣意表达式（能够包括运算）：
   * int a[3*i+5];
   * int b[j+k];
   * 变长数组首要约束是没有静态存储期限,没有初化式
   */
   int vla[3*N+M];
 }

实验程序：

#include <stdio.h>
#define N 10
#define M 11
/**
 * 带参数宏
 */
#define SIZE(array) ((int)(sizeof(array)/ sizeof(array[0])))
int main() {
  /**
   * 1.一维数组
   */
  unsigned int one_dimensional_array[10] = {12, 34, 1,};
  /*sizeof回来类型为size_t为无符号类型,不强转或许会有正告，因为变量i为有符号整数*/
  for (int i = 0; i < (int) (sizeof(one_dimensional_array) / sizeof(one_dimensional_array[0])); ++i) {
	printf("index of One dimensional[%d]:%d\n", i, one_dimensional_array[i]);
  }
  /*
   * 运用宏界说替换长度核算
   */
  for (int i = 0; i < SIZE(one_dimensional_array); ++i) {
	printf("\tindex of One dimensional[%d]:%d\n", i, one_dimensional_array[i]);
  }
  /**
   * 8.2.1多维数组
   */
  int multi_dimensional_array[M][N] = {{1, 2, 3}, {4, 5, 6}};
  printf("multi dimensional array [%dx%d] value:\n", M, N);
  for (int i = 0; i < M; ++i) {
	printf("\n");
	for (int j = 0; j < N; ++j) {
	  printf("index[%d][%d] = %d  ", i, j, multi_dimensional_array[i][j]);
	}
  }
  /**
   * 8.2.2 常量数组 constant arrays
   * 界说：在数组前面加 const
   */
  const char hex_chars[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
  for (int i = 0; i < SIZE(hex_chars); ++i) {
	printf("\n constant hex char [%d] = %c", i, hex_chars[i]);
  }
  /**
   ** 8.3 c99中的变长数组VLA
   * 变长长度不一定用变量来指定，恣意表达式（能够包括运算）：
   * int a[3*i+5];
   * 变长数组首要约束是没有静态存储期限,没有初化式
   */
  int vla[3 * N + M];
  for (int i = 0; i < SIZE(vla); ++i) {
	printf("\t VLA[%d]:%d\n", i, vla[i]);
  }
  return 0;
}

八、函数

界说语法

return-type  function-name (parameters){
    declarations
    statements
}

声明语法

函数声明形参名也可省掉：
如 int sum(int a[],int size); 可变为： int sum(int [],int );

return-type  function-name (parameters)

实践参数

过程	描绘
值传递	实践参数是经过值传递：调用函数时，核算出每个实践参数的值，并且把他赋值给相应的形式参数。在履行过程中，对形式参数的改动不会影响实践参数的值。因为形式参数中包括的是实践参数值的副本。
转化	C答应实践参数与形式参数类型不匹配情况下函数调用，履行实践参数的提升转化

int sum(int a[],int length)
int sum(int a[][M],int length)

int sum(int n,int a[n])
int sum(int n,int a[*])

int sum(int [static 10], int)

九、程序结构

十、指针

指针变量

在核算机中,指针取值规模或许不同于整数取值规模，能够用指针p存储变量i的地址，也便是说指针便是地址，指针变量便是存储地址得变量

取址运算符、直接寻址运算符、指针赋值

int main(){
    int i=0,*p;//声明指针变量p
    p=&i;// & 取址运算符，p指向i,把i的地址赋值给了指针p
    int k=1,*q=&k;//合并写法
    printf("%d",*p);// *（直接寻址运算符）拜访存储在目标中的内容 ，也可幻想成&的逆运算
}

int main(){
    int i=0,*m,*n;//声明指针变量m,n
    m=&i;// i地址仿制给m
    n=m;// m的内容仿制给n
    *n=2;// 此处i的值变为2
    printf("%d",*p);// *（直接寻址运算符）拜访存储在目标中的内容 
}

指针作为参数

重要效果

• 函数调用中用作实践参数的变量无法改动，当希望函数能够改动变量时， 指针作为参数就能解决此问题。
• 指针传参高效原因是，假如变量需求大量存储空间，传递变量的值有时会糟蹋时间和空间。

void decompose(double, long *, double *);
void decompose(double x, long *int_part, double *frac_part) {
  *int_part = (long) x;
  *frac_part = x - *int_part;
}
int main{
    double pi = 3.1415926;
    long int_part;
    double frac_part;
    // 函数用指针作为参数，改动变量的值
    decompose(pi, &int_part, &frac_part);
    printf("pi int_part=%lu, frac_part=%f\n", int_part, frac_part);
}

const维护指针参数

有时分咱们仅需求查看参数的值，而不想改动他的值也有或许。const关键字维护参数，如void fruit(const int *price)

指针作为回来值

/**
 * 指针作为回来值
 * @return
 */
int *find_middle(int n, int a[n]) {
  return &a[n / 2];
}
int *find_max(int *a, int *b) {
  if (*a > *b) {
   return a;
  } else {
   return b;
  }
}

十一、指针和数组

1.指针算术运算

• 加，减，
• 指针相减为间隔
• 指针比较取决于在数组中的方位
• 复合常量指针（不必先申明一个数组变量）

int main() {
  int a[] = {1, 2, 3, 5, 6, 7, 8, 9, 10};
  int *p = &a[0], *q = &a[6];
  //1. 加整数
  p += 4;
  printf("p %d\n", *p);
  //2. 减整数
  p -= 3;
  printf("p %d\n", *p);
  //3. 指针相减
  printf("q-p = %lld\n", q - p);
  //4. 指针比较(取决于在数组中的方位)
  printf("q>p:%d q<p:%d\n", q > p, q < p);
  //5. 复合常量的指针
  int *k = (int[]) {2, 4, 6, 8, 10};
  k += 4;
  printf("*K=%d\n", *k);
  return 0;
}

2.指针用于数组处理

#define N 10
int main() {
  // Q&A 有些编译器来说，实践上依靠下标的循环发生更好的代码
  int a[] = {1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}, *p;
  for (p = &a[0]; p < &a[N]; p++) {
   printf("%d\n", *p);
  }
  return 0;
}

3.数组名作为指针

用数组名作为指针

能够使数组遍历变得愈加简练，核心体现在下面代码a+N部分

#define N 10
int main() {
  // 数组名作为指针
  int a[] = {1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}, *p,*q;
  // 原始写法
  for (q = &a[0]; q < &a[N]; q++) {
   printf("*q=%d ", *q);
  }
  int sum = 0;
  // 惯用法(更简练)
  for (p = a; p < a + N; p++) {//此处a+N了解为，将a当作指针，然后做了指针的加法运算
   sum += *p;
   printf("\n sum = %d *p=%d", sum,*p);
  }
  return 0;
}

用指针作为数组名

#define N 10
int main() {
  // 用指针作为数组名
  int a[] = {1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}, *p = a, *q = &a[0], *k;
  k = a;
  // 三种效果相同
  for (int i = 0; i < N; ++i) {
   printf("p[%d]=%d\n", i, p[i]);
   printf("q[%d]=%d\n", i, q[i]);
   printf("k[%d]=%d\n", i, k[i]);
  }
  return 0;
}

4、指针和多维数组

数组指针和指针数组

int (*p)[n];//数组指针
int *p[n];//指针数组

名词了解：

方便区别中间加上“的”字

数组的指针：是一个指针，什么样的指针呢？指向数组的指针。
指针的数组：是一个数组，什么样的数组呢？装着指针的数组。

了解办法：

形容词+首要名词

step1：由优先级（）>[]>*确认首要名词

step2: 由剩下部分确认形容词

二维数组的队伍

#include <stdio.h>
#define N 10
#define M 10
int main() {
  // 用指针作为数组名
  int a[M][N] = {{1, 2, 3, 5, 6, 7, 8, 9, 10, 11},};
  printf("eg1:运用指针打印数组 \n");
  int *p;
  // 1.按在存储上的特点，当成一维数组（Q&A:合法可是可读性差，在现代编译器上的速度优势很少乃至没有）
  for (p = &a[0][0]; p < &a[M - 1][N - 1]; p++) {
   printf("%d ", *p);
  }
  printf("\neg2:运用指针更改行\n");
  // 2.运用指针更改第m行
  int *row, m = 2;
  for (row = a[m]; row < a[m] + N; row++) {
   *row = 20;
  }
  /* 数组指针vs指针数组
   * Tips:
   * 优先级：()>[]> *
   * 数组的指针：int (*y)[N]为数组指针,可了解为 int(*y)[N]是个含有N个元素的数组类型指针
   * 协助记忆：step1.一个一般指针 int *y ，依据优先级，（*p）是一个指针，详细是个xxx的指针
   *         step2.一个数组类型指针需求后边加上[],变为数组类型指针,因为优先级联系，需求将用括号（）将 *y 包裹起来,变为int (*y)[]
   *         step3.在step2上没办法确认数组类型指针以此走多少步，所以在[]上参加步长N，最终为 int (*y)[N]
   *
   * 指针的数组：int *y[N]为指针数组,可了解为 N个指针元素的数组
   * 协助记忆：step1.依据优先级，p[]是一个数组,是个xxx的数组
   */
  // 3.运用指针更改第n列
  printf("\neg3:运用指针更改第n列\n");
  int (*y)[N], n = 3;
  for (y = &a[0]; y < &a[M]; y++) {
   (*y)[n] = 30;
  }
  // 4.常见嵌套遍历
  for (int i = 0; i < M; ++i) {
   for (int j = 0; j < N; ++j) {
     printf("a[%d][%d]=%d ", i, j, a[i][j]);
   }
   printf("\n");
  }
  return 0;
}

十二、字符串

1.字符串字面常量

C言语如何存储字符串

c言语将字符字面常量当做字符数组来处理，长度为n的字符串，体系会分配长度为n+1的内存空间

字符串变量

声明变量并初始化

char date1[8]="June 14";与 char date2[9]="June 17";与char date3[7]="June 19";

字符数组与字符指针

int main() {
  //惯用法，因为结束空字符
#define STR_LENGTH 8
  char name[STR_LENGTH + 1] = "abc";
  char *p_str = "hello world!";
  char c_array[] = {'a', 'b', 'c'};
  char c_array2[] = "abc2";
  char *p;
  p=c_array;//p作为字符串之前,有必要把p指向字符数组
  int size_name = (sizeof(name) / sizeof(name[0]));
  for (int i = 0; i < size_name; ++i) {
   printf("name# %c total=%d\n", name[i], size_name);
  }
  int i = 0;
  while (((int) *p_str) != '\0') {
   printf("p_str#%d %c\n", i++, *(p_str++));
  }
  printf("p_str#end %c\n", *p_str);
  return 0;
}

2.字符串读写

printf()与puts()写(打印)函数

scanf()与gets()读(输入)函数

#include <stdio.h>
#include <string.h>
#define  NEXT "(y/n)"
#define  YES "y"
#define  NO "n"
int main() {
  char str[] = "we have fun yet!";
  char *str2 = "we have fun2 yet! 酷";
  char str3[3] = "abc";
  //1.字符串写
  printf("%.6s\n", str);
  printf("%s\n", str2);
  printf("%s\n", str3);
  //2.字符串读
  char str_a[3] = "abc";
  /*
   *运用scanf()办法
   */
  while (1) {
   printf("input by scanf():\n");
   scanf("%s", str_a);
   puts(str_a);
   int size_s_str = (sizeof(str_a) / sizeof(str_a[0]));
   printf("s_a size=%d \n", size_s_str);//本机测验输入超越3任然能显现（内存越界或许发生不可思议的成果）
   printf("从头输入%s?：\n", NEXT);
   scanf("%s", str_a);
   if (strcmp(str_a, NO) == 0) {
     break;
   }
  }
  getchar();
  /*
   *运用gets()办法
   */
  while (1) {
   printf("input by gets():\n");
   gets(str_a);
   puts(str_a);
   int size_s_str = (sizeof(str_a) / sizeof(str_a[0]));
   printf("s_a size=%d \n", size_s_str);//本机测验输入超越3任然能显现（内存越界或许发生不可思议的成果）
   printf("从头输入%s?：\n", NEXT);
   gets(str_a);
   if (strcmp(str_a, NO) == 0) {
     break;
   }
  }
  return 0;
}

逐字符读入字符串&自界说read_line()

考虑的问题：

• 存储前是否该越过空白字符
• 什么字符导致函数中止读取，存储还是疏忽这类字符
• 字串太长无法存储，怎样处理剩下字符，丢掉还留给下一次输入

举例：界说一个不越过空白，在换行符中止（不存储），疏忽额定字符的read_line()函数

int read_line(char[], int);
int read_line(char str[], int n) {
  int ch, i = 0;
  while ((ch = getchar()) != '\n') {
   if (i < n) {
     str[i++] = ch;
   }
  }
  str[i] = '\0'; //手动加字符结束
  return i;
}
int main() {
  char str[] = "we have fun yet!";
  int length = read_line(str, 4);
  puts(str);
  printf("length=%d",length);
  return 0;
}

举例2：从规范输入中读取字符，直到遇到换行符 '\n' 停止，函数回来为输入的字符内容

typedef char *String;
String read_line() {
  String s1 = NULL;
  int size = 0, capacity = 1;
  s1 = (String) malloc(capacity * sizeof(char)); // 分配内存
  if (s1 == NULL) {
   printf("过错：内存分配失利。\n");
   exit(EXIT_FAILURE);
  }
  char c;
  while ((c = getchar()) != '\n') {
   s1[size++] = c;
   if (size == capacity) { // 假如需求，增加容量
     capacity *= 2;
     s1 = (String) realloc(s1, capacity * sizeof(char));
     if (s1 == NULL) {
      printf("过错：内存分配失利。\n");
      exit(EXIT_FAILURE);
     }
   }
  }
  s1[size] = '\0'; // 增加空字符
  return s1;
}

C言语中常见字符串库

<string.h> 中有许多操作字符串的函数，下面列举少数几种

函数名	原型	描绘
strcpy	char *strcpy(char *s1,const char *s2)	1. 仿制s2到s1，直到遇见s2榜首个空字符(此空字符也仿制) 2. 不改动s2,函数回来s1指针
strlen	size_t *strlen(const char *s)	回来数组中字符串长度
strcat	char *strcat(char *s1,const char *s2)	s2内容(含'\0')追加到s1结束，回来s1(指针)
strncat	char *strcat(char *s1,const char *s2,int n)	1.s2追加到是结束，遇空字符停止 2.n为待仿制字符数(不包括'\0'空字符) 3.更安全
strcmp	int *strcmp(const char *s1,const char *s2,int n)	利用字典次序比较 空格符<数字<大写<小写字母

#include <stdio.h>
#include <string.h>
#define MAX_REMINDER_SIZE 60
#define MSG_SIZE 60
int read_line(char *, int);
int read_line(char s[], int n) {
  int count = 0, ch;
  while ((ch = getchar()) != '\n') {
   if (count < n)
     s[count++] = ch;
  }
  s[count] = '\0';
  return count;
}
/*
 *
 * 月提醒列表：
 * 按日期排序，输入0打印,打印格局如下
 *      day reminder
 *        5 task1
 *        9 task2
 *       15 task3
 *       25 task4
 */
int main() {
  //1.按日期从小到大提示 day msg,其间day右对其，msg左对其
  //2.超越MAX_REMINDER_SIZE,不能录入
  //3.输入0时分显现一切内容
  char reminders[MAX_REMINDER_SIZE][MSG_SIZE + 3];//保存
  char day_str[3], remind_msg[MSG_SIZE + 1];//日期字串 音讯字串
  int day_number = 0, msg_count = 0;
  char s1[10] = "abc", s2[10] = "xyz";
  strcpy(s1, s2);//xyz
  strcat(s1, s2);//xyzxyz
  printf("%lld", strlen(s2));
  for (;;) {
   if (msg_count > MAX_REMINDER_SIZE) {
     puts("+++++++++++ No space left++++++++");
     break;
   }
   printf("Enter a day and reminder:");
   scanf("%2d", &day_number);
   if (day_number == 0) {
     break;
   }
   //读入前两位数字并保存到
   sprintf(day_str, "%2d", day_number);
   //读取指定长度字符
   read_line(remind_msg, MSG_SIZE);
   //按日期小到大排
   int i = 0, j = 0;
   //从0行开端，找到按日期巨细排的方位i
   for (i = 0; i < msg_count; i++) {
     if (strcmp(day_str, reminders[i]) < 0)
      break;
   }
   // 假如i的方位是小于当时msg总数，则将此条msg刺进i行，i行后边的往后挪一行
   for (j = msg_count; j > i; j--) {
     strcpy(reminders[j], reminders[j - 1]);//将j-1行挪到j行
   }
   //仿制日期到行
   strcpy(reminders[i], day_str);
   //拼接msg到后边
   strcat(reminders[i], remind_msg);
   msg_count++;
  }
  printf("day reminder\n");
  for (int i = 0; i < msg_count; ++i) {
   printf(" %s\n", reminders[i]);
  }
  return 0;
}

字符串数组

存储字符串数组最佳的办法：

• 最显着办法：数组式，缺陷比较糟蹋空间
• 省空间办法：指针式

/*
 * 存储字符串数组最佳办法
 */
int main() {
  //办法一：数组式（废空间）
  char plant_a[][8] = {"Mercury", "Venus", "Earth",
                       "Mars", "Jupiter", "Saturn",
                       "Uranus", "Neptune", "Pluto"};
  //办法二：指针式
  char *pant_b = {"Mercury", "Venus", "Earth",
                  "Mars", "Jupiter", "Saturn",
                  "Uranus", "Neptune", "Pluto"};
  return 0;
}

指令行参数

/*
 * 指令行参数
 * 如：ls -l count.c
 * arg[0]程序名 剩下为余下指令参数，最终附加一个空指针argv[argc]=NULL
 */
int main(int argc,char* argv[]) {
  for (int i = 0; i <= argc; ++i) {
    printf("%d=%s\n",i,argv[i]);
  }
  char **p;
  for (p=&argv[0];*p!=NULL;p++){
    printf("%s\n",*p);
  }
  return 0;
}

十三、预处理器

1.预处理器原理

如gcc <SourceFile> -E 能够看到预处理器的输出

注意： 预处理器仅知道少数C言语的规矩。因而在履行指令时是有或许发生不合法程序，有时看起来正常但过错找起来难，能够查看一下预处理输出是一种办法

2.预处理指令

特征:

1. 指令都以#开端
2. 指令的符号间能够刺进恣意数量空格或水平制表符
3. 指令总在榜首个换行符出结束，除非运用 \ 符参加当时行结束，明确地指明要延续
4. 指令能够出现在程序的任何地方
5. 注释能够和指令放在同一行

部分预处理指令：

3.宏界说

特别__func__标识符与预处理器无关，相当于当时履行函数都的函数名字符串变量

#include <stdio.h>
/*
 * 1. 简略宏
 */
#define N 10
#define D "=%d\n"
/*
 * 2.参数宏
 */
#define IS_EVEN(n) ((n)%2==0)
/*
 * 3. #运算符，用于参数宏的替换列表中，字符串化
 */
#define P_INT(x) printf(#x D,x)
/*
 * 4. ##运算符，粘合两个记号，将两个记号变为一个记号
 */
#define M_K(n) i##n
#define JOIN(x,y,z) x##y##z
int main(){
IS_EVEN(3);
int a=3,b=2;
P_INT(a-b);
int M_K(1)=1,M_K(2)=2;// 相当于声明i1,i2
P_INT(i1-i2);
/*
 * 5. 预界说宏，整数常量或字符串字面量
 */
  puts(__DATE__);
  puts(__TIME__);
  printf("%d",__STDC__);
  printf("%s %d",__FILE__,__LINE__);
  /*
  * 6. 空宏参数
  */
  int M_K()=0;
  P_INT(i);
  int JOIN(r,,),JOIN(r,s,t),JOIN(r,,t);
  r=1,rst=2,rt=3;
  /*
   * 7 参数个数可变的宏,...省掉号在参数列表最终,__VA_ARGS__专用标识符，代表与...对应的参数
   *
   */
#define TEST(condition,...) ((condition)? \
              (printf("test passed:%s\n",#condition)): \
              (printf(__VA_ARGS__)))
  TEST(3>2,"3>2 %s","test");
  TEST(2>3,"output %d is not big than> %d\n",2,3);
  /*
   * 8. __func__标识符，与预处理器无关，每函数都可拜访
   */
  printf("%s return",__func__ );
#undef N
  return 0;
}

十四、 构建大型程序

多文件程序的文件

#include 包括规矩

头文件中的一般其他内容

// 举例一个头文件包括内容
#ifndef PROGRAM_COURSE_H_
#define PROGRAM_COURSE_H_
#define TRUE 1
typedef int BOOLEAN;
int value;
extern int ext_value;
int sum(int,int);
#ifndef __STDC__
#error "This C program requires a Standard C compiler!"
#endif
#endif //PROGRAM_COURSE_H_

十五、 结构&联合&枚举

概述

命名和用法

两种命名的办法

#include <stdio.h>
/*-----------------------结构----------------------------*/
//省掉了结构符号
struct {
  int version_1;
  char name_1;
} a1;
//（结构）界说办法1：包括了结构符号
struct Part {
  int version_1;
  char name_1;
} b1, b2, b3;//一起声明3个结构体变量，也可不在此处声明
struct Part b4;//声明一变量
//（结构）界说办法2：运用typedef
typedef struct {
  int version_2;
  char name_2;
} Part2;//此处运用类型界说将结构命名为类型Part2
Part2 c1, c2;//声明两个变量
/*-----------------------联合----------------------------*/
//（联合）界说办法1：包括了联合符号
union Union_1 {
  int weight;
  double name;
} d1, d2, d3;//一起声明3个联合变量，也可不在此处声明
//（联合）界说办法2：运用typedef
typedef union {
  int version_2;
  char name_2;
} Union_2;//此处运用类型界说将联合命名为类型Part2,
/*-----------------------枚举----------------------------*/
enum { ONE, TWO, THR } f1;//界说3个枚举常量 和一个变量
enum Enum_1 { FIV, SIX } f2;// 办法一：包括了枚举符号
typedef enum { TRUE=1, FALSE=0  } BOOL;//办法2：运用typedef类型界说

十六、指针高档应用

动态存储分配&空判断&开释

十八、 声明

声明阐明符

• 存储期限：内存单元的开释和取得
• 效果域：能够引证变量的那部分程序文本
• 链接：同享变量的规模，外部链接能够被几个或全部文件同享，内部链接归于单一文件，无连接归于函数独享

类型限定符

声明符

• 包括标识符，标识符前面或许有*，后边或许有[],()。3种符号组合能够创立杂乱声明
• 解说杂乱声明
  • 从内向外
  • 挑选优先级，（）> [] > *
• 能够用类型界说来简化杂乱声明

初始化式

初始化变量

未初始化的变量

未初始化变量有未界说的值，但并不总是这样

• 主动存储期限变量没有默许初始值。不能预测初始值，每次变量变为有效时值或许不同
• 静态存储期限变量默许情况初始值为0。

内联函数

• 额定开支：调用函数和函数回来所发生的工作量。
• 运用内联函数inline：减少额定开支。依靠编译器，有的编译器能够疏忽这一主张。
  • 函数中不能界说可改动的static变量。c99
  • 函数中不能引证具有内部链接的变量。c99

十九、 程序设计

1. 模块

   • 聚合性

     低耦合高内聚

   • 类型
     数据池	一些相关变量或常量的调集，如<limits.h>
     库	相关函数的调集
     抽象目标	关于躲藏的数据结构进行操作的函数调集
     抽象数据类型ADT	详细数据完成办法躲藏起来的数据类型称为抽象数据类型

2. 信息躲藏

   • 标题
     安全性
     灵活性

3. 抽象数据类型

   • 标题
     封装	其他言语对封装支撑要好一些
     不完整类型	描绘了目标，但缺少界说目标巨细的信息

4. 抽象数据类型例子 —— 栈运用不同办法完成（详细见示例程序）

   • 运用定长，变长，链表完成，但用同一个头文件

二十、 底层程序设计

1. 位运算符

2. 结构种的位域

3. 其他底层技能

二十一、 规范库

二十二、 输入、输出

1. 流

2. 文件操作

标题
翻开文件	fopen(文件名，形式)	参看形式表
关闭文件	fclose(文件指针)	参看形式
翻开的流附加文件	freopen(文件名，形式，附加文件指针)	附加文件指针一般为规范流或其他
临时文件	1.File *tempfile(void) 2.char *tempnam(char *s)	1. tempfile,易用，缺陷不能命名，按需保存起来 2. tempnam生成一个唯一的、可用于命名临时文件的字符串，你需求手动将其作为参数传递给其他函数（如 fopen()）以创立实践的临时文件。请注意，在某些体系上，因为安全性问题而不推荐运用此函数。
文件缓冲	1. fflush(文件指针) 2. void setbuf(文件指针，缓冲数组，<缓冲形式>，>运用缓冲巨细>)	1. fflush清洗文件缓冲区 2. setbuff 按巨细方位缓冲类型(_IOFBF,_IOLBF,_IONBF)操控缓冲流
文件重命名	rename(旧名，新名)
文件删去	remove(文件名)
文件定位	1.fseek移动到文件的某些方位 2.ftell回来当时文件方位 3. rewind把文件方位设置在开端处 4.fgetpos获取文件方位 5.fsetpos设置文件方位

3. 输入输出

代码操练片段链接

二十三、 库对数值和字符数据的支撑

包括浮点，整数巨细，数学核算函数，字符处理，和字符串的处理，此处省掉

二十四、 过错处理

二十五、 国际化

包括<local.h>、多字节字符和宽字符、双字符三字符、通用字符名，<wchar.h>扩展多字节、<wctype.h>宽字符分类和映射东西

二十六、 其他库函数

总结

1. 《C Programing:A Modern Approch》2th 是一本优秀的C言语学习书本，由浅入深介绍，对读者非常友爱，学后还能依据重复部分再进一步整理缩减。
2. 关于图形编程，多线程，进程知识点是后边需求参照其他书本进行弥补
3. 实践代码加深形象