C基础

1-结构话程序设计：自顶向下，逐步细化，模块化设计，结构化编码
2-C语言程序设计以函数为单位
3-数据类型，指定数据取值范围及对该数据可进行的操作
4-<编辑器（*.c, *.cpp）--预处理--编译器(*.obj)--连接器(*.exe)>(磁盘)--载入器--内存--CPU
5-标识符，大小写字母/下划线开头， 字母下划线，数字组合
6-数据类型-基本数据类型(enum)、指针数据类型，构造数据类型（struct,union）
7-整型 八、十、十六进制。  short类型两个字节，-32768~32767
_int8 = char
_int16 = short
_int32 = int = long
_int64 = long long
int i = 017;  // 八
int j = 15;
int k = 0x0f; // 十六
// 三个值相等都是15
unsigned short twobyte; // 0 - 65535
unsigned fourbyte;  
unsigned long fourbyte;  // 因系统而变，long unsigned也可以，关键字顺序可以改变
8-科学计数法， E|e在中间  左边小数/整数（.77），    右边整数（正负0）
9-小数 double/float 常量系统默认为double,  float k = .33; 警告，.33为double类型
10-空void，这种指针可以指向任意类型
11-字符型char,  'a',   转义字符'\n'...， 不支持中文
12-字符串类型，支持中文。
13-常量  字面常量，标识常量（只读，且必须声明即初始化）
const int MIN = 0;  // int const 也一样
14-引用：变量和对象别名（必须声明即初始化）
int x = 8;
int &t = x;   // x,t共同对应一个内存，都可以修改内存中的数值
const int &f = x;  // 常引用，只能读取8，不能修改8
&f // 脱离int，&不是引用意思，而是取地址了
15-运算符-初等运算符--单目--算术--左右移--关系--位运算符
++在前，是+,后使用
/ （支持浮点型）
% （只支持整数，余数符号由被除数决定），位运算只支持整数
<< 右边补0     >> 无符号数，补0 ，有符号，符号位是1，补1，符号0，补0

优先级

运算符

名称或含义

使用形式

结合方向

说明

1初等运算符，除了（）都是关于寻址的

[]

数组下标

数组名[常量表达式]

左到右

  

()

圆括号

（表达式）/函数名(形参表)

  

.

成员选择（对象）

对象.成员名

  

->

成员选择（指针）

对象指针->成员名

  

2单目运算符

-

负号运算符

-表达式

右到左

单目运算符

(类型)

强制类型转换

(数据类型)表达式

  

++

自增运算符

++变量名/变量名++

单目运算符

--

自减运算符

--变量名/变量名--

单目运算符

*

取值运算符

*指针变量

单目运算符

&

取地址运算符

&变量名

单目运算符

!

逻辑非运算符

!表达式

单目运算符

~

按位取反运算符

~表达式

单目运算符

sizeof

长度运算符

sizeof(表达式)

  

3算术运算符

/

除

表达式/表达式

左到右

双目运算符

*

乘

表达式*表达式

双目运算符

%

余数（取模）

整型表达式/整型表达式

双目运算符

4

+

加

表达式+表达式

左到右

双目运算符

-

减

表达式-表达式

双目运算符

5

<<

左移

变量<<表达式

左到右

双目运算符

>>

右移

变量>>表达式

双目运算符

6关系运算符

>

大于

表达式>表达式

左到右

双目运算符

>=

大于等于

表达式>=表达式

双目运算符

<

小于

表达式<表达式

双目运算符

<=

小于等于

表达式<=表达式

双目运算符

7

==

等于

表达式==表达式

左到右

双目运算符

!=

不等于

表达式!= 表达式

双目运算符

8位运算符

&

按位与

表达式&表达式

左到右

双目运算符

9

^

按位异或

表达式^表达式

左到右

双目运算符

10

|

按位或

表达式|表达式

左到右

双目运算符

11

&&

逻辑与

表达式&&表达式

左到右

双目运算符

12

||

逻辑或

表达式||表达式

左到右

双目运算符

13

?:

条件运算符

表达式1? 表达式2: 表达式3

右到左

三目运算符

14赋值预算符

=

赋值运算符

变量=表达式

右到左

  

/=

除后赋值

变量/=表达式

  

*=

乘后赋值

变量*=表达式

  

%=

取模后赋值

变量%=表达式

  

+=

加后赋值

变量+=表达式

  

-=

减后赋值

变量-=表达式

  

<<=

左移后赋值

变量<<=表达式

  

>>=

右移后赋值

变量>>=表达式

  

&=

按位与后赋值

变量&=表达式

  

^=

按位异或后赋值

变量^=表达式

  

|=

按位或后赋值

变量|=表达式

  

15

,

逗号运算符

表达式,表达式,…

左到右

从左向右顺序运算
16-类型转换 隐式类型转换，低类型数据转换高类型， 强制转换（int）a; int (a);
17-goto, 
loop: cin >> number;
        number = - number;
        goto loop;
18-break;跳出整个循环，continue重新开始循环，for(;;)永真。
19-exp1?exp2:exp3;   exp1真执行exp2,假执行exp3;
20-do, while for
21-switch, case语句没有break,会往下继续执行。这次不用判断是否符合。仅支持字符，整型，枚举
switch(x)
{
case 1:       // 1执行后，继续2，因为没有break;
case 2:       break;    // 执行后不会，有break;
default:           // java还是会有。不需要break;  
}
22-数组-具有一定顺序关系的若干相同类型变量集合体，内存连续，多维也是。
22.1数组名，数组存储空间的开始地址，*a,可以取到第一个值，&a==a,  不可改变，a++会报错，之后将其付给指针，用指针才能加加。，sizeof(a)得到数组的大小，而不紧紧是指针的大小，int *p, sizeof(p)为4
22.2数组没有初始化的，默认为0
22.3字符数组末尾一定要为‘/0’。不然系统会默认为‘/0’;如果刻意这样 char a[2] = {'a','c'};就不是字符串数组了。
// 特殊表示法
int a[5] ={1,5,5,6,4}; int i = 4; 
a[4] = 4[a] = i[a];
// 一维数组
    int a[] = {2,3};  // 可以不是先说明数组元素个数，但是一定要先初始化，a[2]可以不用。不说个数一定要先初始化。
    cout << *a << endl;

    // 二维数组
    int b[][4] = {4,{3}};  // b是二维指针不能赋值给一维指针
    int c[3][4] = {13};  // c[0]类似上面的a，是一个指针。c是一个二维指针，指向三个指针，指针又指向数组
23-指针，四个字节，变量或常量的地址
23.1两个指针，一个new出的，一个非new的，一个指向堆，一个指向栈，或者没有指向
delete的工作就是让刷新p指向的内容，标记该块内存可用。p的指向没有改变。但这个指向随时有被系统回收的危险
一个指向栈的指针，让他指向堆之后，他就和new的没有差别了，同样可以delete
int a[5] = {1,2,3,4,5};
sizeof(a); // 20  指针作为参数，会丢失size,这是数组和指针一模一样
int func(int *a)
{
sizeof(a); // 4;
//定义数组a[5];sizeof（a）为20；将a赋给指针p。sizeof(p)还是为4；即使是p = new int[5];还是4。 那是因为sizeof 操作符不能返回动态地被分派了的数组或外部的数组的尺寸
// 数组是静态的。数组是存在栈里的，不能什么太大的，少用好。
//数组的首地址就是sizeof得到的是整个数组的大小，而其他指针都是4，即使是由数组首地址或者malloc，new分到的数组都是4
// 1-sizeof求系统分配的内存，而strlen求个数，仅适用于char *

}
23.2,常指针比普通指针多了个可以指向常量的功能，指针常量则，现在指针不能改变指向，两个综合也就都具备而已

类型

 

指针变量

Int *p;

指向常量的指针

Const int *p;

指针常量

Int *Const p;

指向常量的指针常量

Const int *const p;

是否可以指向变量

是

是

是（指针是常量，一指向无法修改）

是

是否可以指向常量

否（p指针无法通过const 指针赋值）

是

否（和左边第二格一样）

是（由于多了个const）

是否可以重新指向

是

是

否

否

是否可以改变指向的内存单元的值

是

否（*p）就是一个const int,不可改变值，因为指向的是const

否

否

 

是否可以*p++;

 

是

是

否

否

 

 

是否可以P++;

 

 

是

是

否

否

++在前面也同样。
    int *p;
    cout << *p; // 报错，一定要先赋值后使用
    void *p1;  // 可以指向任何类型，其他要指向相同类型
23.3二级指针，二级指针变量存储的是一级指针变量的地址
int x = 0;
int *p = &x;
int **pp = &p;  // 二级指针指向的只能是一级指针变量的地址，*p是p指向的值，而&p是p的地址，不是x的地址
23.4.0指针数组，  int *a[5];  a[4] = &x;数组元素的值是地址
23.4.1指向数组的指针int (*a)[5]; a是二维指针，只能指向一维指针的地址
int (*a)[5];
int b[5];
a = &b;  // 指向数组的指针，只能指向数组元素为5的，其他不行。
// *a是b[0]的地址， **a是元素b[0]的值

23.4.2指向二维数组的指针，二维数组的数组名是一个二级指针

int (*a[2])[3];  a[0] 指向长度为3的int型数组的指针变量，就是上面那个的数组版。 
int (*a[2])[3];
int b[2][3] = {{1,2,3},{4,5,6}};
a[0] = b;
cout << **a[0];  // 等于b[0][0];
cout << **(a[0] + 1);  // 等于*(a[0]+1)是a[1][0]的地址
23.5new和delete处理
int *a = new int;
int *b = new int(4);
delete a;  // 释放单个
int *c = new int[4];
delete []c;  // 释放数组
23.6指针不要做的操作
将两个指针相加/将常数和指针相乘/将指针除以常数
24-字符，字符串
字符串数组，'\0'结尾，不然输出会有乱码，就不是字符串数组了，可以通过指针整个操作
sizeof() //求内存
strlen() //求到\0有多少个 \0不包括
char a[50] = {'a','b','c','d'}; // 末尾自动补零
char a[] = {'a','b','c','d'}; // 末尾不自动补零,要一起输入才没事
char *a = "abcd"; // 自动补零,可是不可改动,只能整个指针改变指向
‘0’字符
0 结束标志
‘\0’ 结束标志
char *p最好用于比较p代表第一个字符,可以通过加加来移动
函数参数用char a[];
25-结构类型， 变量通过.索引，指针通过->索引
#include <iostream>
using namespace std;

struct DATE
{
    int year;
    int month;
    int day;
};
struct PERSON
{
    int id;
    char name[20];
    DATE birthday;
};

int main()
{
    PERSON person = {10001, "张", {1977, 12, 12}};
    PERSON *p_person;
    p_person = &person;
    cout << person.id << endl;
    cout << p_person->name << endl;
    return 0;
}
26-枚举类型enum 名字｛标识符，标识符｝；
(1)枚举类型按常量处理，不能赋值
(2)枚举元素，没有赋值，重0开始，累加
(3)enum weekday{sun = 7, mon = 1, tue, wed, thu, fri, sat};  // tue重2开始
(4)常量可以强制转换为枚举类,就是常量，可以进行运行运算,enum 的对象可以赋值给整型，会自动转换，但整型不可以赋值给enum对象，要强制类型转换。
weekday day;
day = weekday(1);
27-union联合体
在与硬件交互时常常需要用到
联合体占的内存大小是元素中占内存大小最大的那个的内存大小值
联合体可以嵌套在联合体中，也可嵌套在结构体中
用于包含不会同时出现的元素变量，这样就不会出现被修改，或者浪费内存了。
28-控制台输入输出
 
格式函数
 非格式函数
类型 输入 输出 类型 输入 输出
char
scanf() //遇到空格结束,有两个一起
输入是不结束scanf("%d%d",&a,&b);
sscanf()格式输入
 printf() char
getch()
getche()
getchar()
putch()
putchar()
int int    
float float    
string string gets() puts()
 
数据类型   格式控制符
整型
有符号短整型
无符号短整型
有符号长整型
无符号长整型
无符号十六进制
无符号八进制
%d或%I
%u
%ld
%lu
%x
%o
实型
浮点型
double型
%f
%lf
字符
有符号字符
无符号字符
%c
%c
字符串   %s
控制符
 说明
数字 指定字段宽度的位数
. 区分字段宽度与精度的小数点
数字 指定精度的位数
-负号 表示在指定宽度内左对齐输出
 
  1. %-15.9lf // %在最前,整个输出占15个位置,9表示小数点输出9位
  2. sprintf(str, "%c %d",ch, i); //不用与屏幕输入输出
  3. gets从键盘接收到\n时就停止接收，并将\n换成\0
  4. getline等不是键盘或屏幕的操作
  5. 用lf于float类型会出现错误,
  6. 注意输出,如果双引号内的类型和外面的类型不同可能会出错.
  7. 输入的要记得加&,类型不对应也会出错,一直输入为0
29-函数
29.1-要改变到参数的值，要么用指针，或者引用。要将两个值交换就得如此
29.2-原型声明可以多次，定义只能一次
29.3-默认形参，顺序必须是从右向左的
int add(int x, int y = 5, int z = 6); // 从右开始，对
int add(int x = 1, int y = 5, int z); // 从左开始，错
int add(int x = 1, int y, int z = 6); // 不连续，错

29.4-函数可以返回指针，称为指针函数， int *f();   // 注意不要返回局部变量，因为函数结束，系统会销毁

29.5-函数返回引用 // 返回实际值，占用内存较大时，可以返回引用。返回的也不能是局部变量，
int &fun(int &x)  // 传进来的参数，修改后在返回，才是正确的使用方法
{
    return x;
}
29.6-内联函数，用于小巧函数，系统编译时，会将内联函数，用整个函数内容替换。
29.7-重载函数：c没有，重载是c++的概念
29.7.0-能够根据函数参数的个数和类型不同确定所要调用的函数
29.7.1-参数个数，或者参数类型，参数顺序不同算重载，而返回值不同，函数体不同都不算重载。
30-预处理命令
原理
1、宏从C保留下来，它与inline函数十分类似，只是没有进行类型检查，只是原样的展开
2、在编译之前，预处理器要先对宏定义进行检查，替换
3、宏可分为带参数与不带参数
4、宏定义可出现在程序中的任何位置。通常，将宏定义放在源程序文件开始部分。宏名的作用域为从宏定义开始到本源程序文件结束
5、宏存在的缺点可以靠inline内联函数来弥补，inline函数继承了宏的优点
6、就是把宏模版后面的所有包括括号都替换
7、#将后面的进行字符串操作，及加上双引号
8、##只是连接两个参数，没有加双引号
优点与不足：
1、给常量取一个容易记忆的名字
2、当某常量多次出现时，要修改可以只改一个地方
3、不需要用栈等，速率更快。没有函数调用的时间消耗
4、没办法修改。避免了const可能被修改报错的
5、在程序中上百次使用宏时，要上百次的替换，产生的扩展源代码很多，而函数上百次调用还是只占有一个空间
6、宏的内存开销可能比函数大，时间开销比函数小。
7、没有类型的检查与转换
8、宏不能够递归
9、宏有碍调试，对变量名等可能造成破坏。
10、宏没有地址
好习惯：
1、整个宏扩展应该包含在括号内
2、大写
3、给每个参数都加括号，在运算中
用法：
1、实现最大值
#define MAX(x,y) (((x) > (y) ? (x) : (y)))
最外层的括号不可省略
2、宏参数的连接
3、定义运算符
#define AND &&
#define OR ||
4、替换条件
#define CONFITION  (a > 25 AND a < 5)
5、替换c语言语句
#define OUT printf("I can use hong")；   //有分号
6、可以分成多行用反斜线 \
#define MM cout << "mm" \                        << endl;
MM    //不用分号。
cout << "mm" << endl;
7、VS2008查看预处理后的文件
项目属性--配置属性--C++--预处理器--生成预处理文件--/p   
此时将无法编译程序，obj找不到 
8、和条件编译合作避免重复编译
#ifndef _HEAD_H
#define _HEAD_H
#endif
9、整型变字符串
#define STR(s) #s
string s = STR(43);
10、科学计算法，十位个位的连接
#define CONS(a,b) (int)(a##e##b)
cout << CONS(1,4);     //10000
如果去除e，则相当于14；
11、得到数组所含元素个数
#define ARR_SIZE(a) (sizeof((a)) / （sizeof((a[0])))
12、得到一个字的高位低位字节
#define WORD_LO(x) ((byte)((word)(x) & 255))
#define WORD_HI(x) ((byte)((word)(x) >> 8))
13、宏的嵌套
#define NUM 2
#define P NUM*2
问题：
1、不可用分号。
2、#define 宏模版 宏扩展  //宏模版与宏扩展之间一定要有空格隔开
3、宏模版与参数之间不能有空格
4、注意运算优先级的影响
5、实参可以为++i，或者其他，但是要注意++i是否用了多次
6、实参也可以是函数，也要注意函数是否多次调用
7、"内"双引号内不置换
例子
#define WARN_IF(EXP) \
do{ if (EXP) \
fprintf(stderr, "Warning: " #EXP "\n"); } \
while(0)
那么实际使用中会出现下面所示的替换过程：
WARN_IF (divider == 0);
被替换为
do {
if (divider == 0)
fprintf(stderr, "Warning" "divider == 0" "\n");
} while(0);
14、条件编译
#ifdef/#ifndef 标识符
程序段
#endif

#ifdef/#ifndef 标识符
程序段1
#else
程序段2
#endif
#define toString(s) #s // 无论s为什么都会变成字符串;
#define lian(x,y) x ## y // 无论x,y传入的是什么,都会被连接在一起,连接后的数如果没有意义就会报错
#define absolute_value( x ) ( ((x) < 0) ? -(x) : (x) ) // 解决了我一问题,就是怎么让一个数取相反数
#error 语句 // 无论语句是否正确都在这里停止
#line _LINE__ // 用于行数改变的,没什么用处
#undef //取消某个已经定义的宏
__LINE__ 和 变量表示的正在处理当前行和. //整数
__FILE__正在处理当前文件 // 字符串形式
__DATE__ 变量表示当前日期,格式为month/day/year(月/日/年). // 字符串形式
__TIME__ 变量描述当前的时间,格式为hour:minute:second(时:分:秒). // 字符串形式
1、预处理指令有四种：
（1）宏指令
（2）文件包含
（3）条件编译
（4）其他指令
 
宏指令的好处：
1、可读性增强，WIDTH 代替10；就可以知道这个是高了。
2、在编译之前会生成宏扩展源代码，可以打开，用于查出错误。后缀名为 .I
#define MAX 5
char a[MAX] = "abcd";
#define sout(s) printf(#s"\n") //不用每次输出文字加双引号,这种
#define sout(s,x) printf(#s"\n",x) // 要加参数 sout(1,2); = printf("1\n", 2);





【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/itc0z0sti/p/3303346.html