字符串是一个或多个字符的序列
字符串不是一个数据类型，而是一个数据结构，通过数组实现

字符串函数：string.h
获取字符串长度：
int strlen(const char* string)
字符串拷贝：
char* strcpy(char* des,char* src)
char* strncpy(char* des,char* src,int size)
字符串比较：
int strcmp(const char* str1,const char* str2)
int strncmp(const char* str1,const char* str2,int size)
1）如果两个字符串相等，返回值为0
2）如果第一个参数小于第二个参数，返回值小于0
3）如果第一个参数大于第二个参数，返回值大于0
字符串连接：
char* strcat(const char* str1,const char* str2)
char* strncat(char* str1,const char* str2,int size)
字符串中查找字符：返回查找到字符的指针或NULL
char* strchr(const char* string,int ch)
char* strrchr(const char* string,int ch) //反向查找
字符串中查找子串：返回查找到子字符串的指针或NULL
char* strstr(const char* string,const char* substring)
查找字符串前缀：
int strspn(const char* str,const char* set)
返回str起始部分匹配set中任意字符的字符数
char* strpbrk(const char* str,const char* set)
返回字符串中第一个出现的字符集中字符的指针或NULL

位操作符:针对二进制的操作

～：按位取反

<< : 左移 乘法,乘以2的N次方，高位的非符号位舍弃

>> : 右移 除法，除以2的N次方，高位的非符号位补零，低位舍弃

& | ^ ：异或

 

 

++ —在运算中的组合

在printf()语句中， printf在确定哥哥变量的结果时，顺序为从后往前

printf(“%d%d%d”,a,b,c); c–> b–>a

 

 

x++ ———–> 取值后加

x– ———–>取值后减

++x ———–>最后确定，不能确定最后是什么最后

–x ———–>最后确定，不能确定最后是什么最后

 

贪心算法

编译器在出现二异性时，编译器会选择尽可能多的结合运算符

 

#include<stdio.h>

int main(void)

{

int x=7;

printf(“x++:%d,x++:%d,x++:%d\n”,x++,x++,x++);

 

x=7;

printf(“++x:%d,++x:%d,++x:%d\n”,++x,++x,++x);

 

x=7;

printf(“x++:%d,++x:%d,x++:%d\n”,x++,++x,x++);

 

x=1;

printf(“%d,%d,%d,%d,%d,%d\n”,++x,x++,++x,x++,x++,++x);

//7,2,3,7,6,7

 

x=1;

printf(“%d,%d,%d,%d,%d,%d\n”,++x,x++,–x,x–,x++,++x);

//x 1 x 3 2 x

//3 1 3 3 2 3

 

x=1;

int y=(++x)+(x++); //2+2

printf(“(++x)+(x++):%d\n”,y);

 

 

int a=1;

int b1=a+a; //2

// int b2=a++a; //error

int b3=a+++a; // (a++) +a = 3

// int b4=a+++++a; // ((a++)++) +a= error ++ 操作带回写

// 表达式的值不能进行++ (a+b)++ error

a=1;

int b5=a+++a+++a+++a; //(a++)+(a++)+(a++)+a

printf(“b3:%d\n”,b3);

printf(“b5:%d\n”,b5);

 

return 0;

}

 

 

问号表达式

int res = a>b?a:b

当问号表达式确定整个表达式的值时，另外一边的运算不被执行。

 

逗号表达式

表达式整体的值为最后一个表达式的值。

 

隐式类型转换

注意无符号和有符号间的转换。

当一个int *float —>float

signed * unsigned —> unsigned

 

空格在C 语言中的意义

int a;

int *p=&a;

int b=100/*p; //此处代码通不过，因为 ／＊＊／为注释 改为：b=100/ *p 加一个空格即可

 

 

数组 —》 聚合数据类型

数组是一组有相同数据类型的数据的集合

格式：存储类型 数据类型 数组名［常量表达式］

数组长度是编译器决定的。数组放在stack

数组在stack是连续存放的，并且是字对齐，不存在奇数

数组越界访问属于非法操作，会引发段错误或其他异常，编译器不会检查数组越界错误，需要由程序员自行检查数组越界错误。

数组名的含义：

左值：整个数组，不要将数组名作为左值来操作，除非用于初始化。

右值：地一个元素存放的地址

sizeof(左值) 默认为左值

int *p=array;

sizeof(p) —> 4 在32位平台，所有指针大小为4

语句

if语句 三种格式

if（表达式）语句／／算数表达之，逻辑表达式，但是必定都有值

if(表达式) 语句一 else 语句二

if（表达式） 语句一

else if（表达式2） 语句二 ………..

else 语句n

 

逻辑短路问题

因为条件控制不当，丢失了部分逻辑处理或运算

1、范围颠倒

if(大范围) >200

…..

else if(小范围) >300 包含在大范围之中，

……. ／／短路

2、&& 和 ||

出现逻辑短路的情况：&& 前一个条件为假， || 前一个条件为真

屏蔽后一个条件的判断和运算（短路）

vi编辑器的缩进功能

自动缩进

=

手动缩进

<

>

 

循环语句

for

 

 

while

 

#include<stdio.h>

int main(void)

{

int sum=1;

int new=0;

int n=0;

while(n<=12)

{

sum=sum+new;

new=sum-new;

n++;

}

printf(“sum is %d\n”,sum);

return 0;

}

 

 

高斯公式运算1-任意数的累加和

 

 

 

 

do while

默认多执行一次循环才开始条件判断

#include<stdio.h>

int main(void)

{

int i=0;

int num;

int sum=0;

//

//scanf(“%d”,&num);

//while(i ！= -1）

//｛

// sum=sum+num;

// scanf(“%d”,&num);

//｝

 

do

{

sum=sum+num;

scanf(“%d”,&num);

}while(num != -1);

printf(“sum is:%d\n”,sum);

return 0;

}

 

break; //跳出整个循环，循环结束

continue; //跳出本次循环，继续下一次循环

本次循环剩余代码将不执行。

！逻辑取反

～按位取反

分支语句

if

switch_case

 

case ［-p］：p可以是整形，字符，枚举

没一个入口后都要加break表示当前入口的代码段结束，default入口结束一般不加break,但是当default入口是非最后一个入口时，需要在其后面加上break

 

可以放在case入口后的作为常量表达式的，字符，常量算术表达式，常量值，枚举类型

 

if else 嵌套层数较多时建议使用switch

如果case 要求使用变量作为比较时，建议if else

 

顺序语句

 

函数

有有时候我们在写点什么的时候，偶尔会遇见说又在矫情了，或者说是又在文艺之类的话语，其实我们想要的仅仅是洗完写点什么来记录下现在的生活，然后在30岁的时候回看20岁的自己，然后在那里大笑自己以前有多傻呆。留一份让自己傻笑的回忆。

浮点类型

float类型 double类型

EG：#include<stdio.h>

#include<float.h>

int main(void)

{

float f;

double d;

long double ld;

printf(“sizeof(float):%d\n”,sizeof(f));

printf(“sizeof(double):%d\n”,sizeof(d));

printf(“sizeof(long double):%d\n”,sizeof(ld));

 

printf(“FLT_MAX:%lf\n”,FLT_MAX);

printf(“DBL_MAX:%lf\n”,DBL_MAX);

// printf(“LDBL_MAX:%lf\n”,LDBL_MAX);

return 0;

}

 

精度丢失

1、浮点类型本身精度不够

2、类型转换丢失（浮点类型<—>整型)

运算表达式的属性由操作数决定，编译器会将表达式的属性向尽量广的范围转换

对于printf();里面的输出格式控制支持位数控制，

float xx=123123.456789

float yy=123123.443442

printf(“xx：%.3\n”,xx);

//%[+-]总长度.小数位 格式，+表示对齐方式(默认) 右对齐,-表示左对齐

//%02d:%02d 输出两位，不够补零

指针

指针常量

字符串常量 char* 表示我们的字符串常量在存放首地址

 

指针（指针变量）存放一个内存地址

地址 8位16进制数表示一个地址（32-bit）

 

0xbf 88 8888 一个字节的数据 0xff

int a;

char b;

 

／／n内存需要申请才是合法的，如果直接复制为地址则是非法的，会报段错误

int ＊p=&a; //取的是首地址

 

char *str;

*str 是一个字符

 

int* a,b,c; 实际上只有a是指针，之后的b,c都是整型

 

typedef 为各类型定义新的名字

eg：

typedef char* ptr_to_char;

ptr_to_char a,b,c; //则所有的a,b,c都是指针

常量：在程序执行中值保持不变的量

两种形式：名字常量，const常量:把变量的格式变为只读格式，

const 修饰的永远都是其后面的东西，

#define 3.141592654

int const a=15; //a=100;错误，所以一般定义的时候都要赋值

int const *pci=&a;

int ＊const cpi=&a;

int const * const cpci; 指向和指向的值都不能改

指针常量:指针是一个常量，指针不能指向其它地方，指向的值可以变–> int * const p

常量指针：指向常量的指针，指针可以变，指向的值不能变。–>int const *pci;

 

eg:

#include<stdio.h>

 

int main(void)

{

int const a=200;

//a=100;

//强制修改

int *pa = &a;//借助指针修改

*pa = 100;

printf(“a:%d\n”,a);

 

 

int i=100;

int j;

int const *p1 = &i;

p1 = &j;

// *p1 = 200;

 

int *const p2 = &i;

// p2 = &j;

*p2 = 200;

return 0;

}

 

 

 

标识符的三大属性：作用域，链接属性，存储类型

作用域 scope

链接属性 linkage

存储类型 storage

 

重定义：在同一作用域内有2个同名的标识符被定义

 

作用域：编译器决定我这个变量的有效范围，具有覆盖性

文件作用域

函数作用域

代码块作用域

原型作用域原型作用域和函数作用域冲突

 

 

 

#include<stdio.h>

 

 

int a; //文件作用域

void fun(int x) //原型作用域

{

int x;//函数作用域 //冲突error

}

 

int main(void)

{

int a;//函数作用域

{

int a; //代码块作用域

}

 

return 0;

}

 

链接属性：与作用域不冲突，链接属性决定着在不同文件（源文件)中是不是同一个实体

external 默认，在不同文件可以是同一个实体

internal 需要使用static关键字+external，在不同文件是不同实体，

none 默认,没有链接属性的标识符，，被当作单独的个体

 

在函数外部定义的变量（全局变量），链接属性为external

全局变量默认初始值为0

在函数内部定义的变量（局部变量），链接属性为none

 

static 关键字

当修饰external 的变量时，将其转变为internal的链接属性

 

当在头文件中声明；int global=100;但是在各文件中包含时，编译时会出错，因为其进行了多次初始化。

加上 static int global=100就可以多次初始化，

external 关键字

把none → external

存储类型

普通内存，运行时栈，硬件寄存器

静态变量，自动变量（局部变量），寄存器变量