C++成长之路

进制
{
四种进制
{
二进制：0,1 //没有
八进制：0,1,2,3,4,5,6,7 //0123
十进制：0,1,2,3,4,5,6,7,8,9 //123
十六进制：0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f //0x123,0X123
}
进制的转换
{
十进制转N进制：十进制数不断除以N，余数反写
N进制转十进制：N进制12ae -->十进制的 1N^3+2*N2+10N^1+14
二进制转八进制：110100101001—>110 100 101 001—>6451
二进制转十六进制：110100101001—>1101 0010 1001—>d29
十六进制转二进制：d29---->1101 0010 1001
八进制转二进制：6451----->110 100 101 001
}
}
内存
{
存储单位
{
位 bit 8bit = 1byte
字节 byte 1024byte = 1kb
KB 1024kb = 1 mb
MB 1024mb = 1 gb
GB 1024gb = 1 tb
TB 1024tb = 1 …
…
giga byte
}
存储顺序
{
大端存储（网络上用这个）:
0x12345678 --》 [12]
[34]
[56]
[78]
小端存储（内存里用这个）:
0x12345678 --》 [78]
[56]
[34]
[12]
}
}
helloworld
{
C,C++的入口点函数
输出命令
}
int
基础数据类型
{
//类型 字节数 字面常量
布尔
{
bool 1 true,false
}
字符
{
char 1 ‘a’ ‘A’ ‘0’
unsigned char 1
wchar_t 2 L’a’ L’A’ L’0’
}
整数
{
short 2
unsigned short 2
int 4 123 -123
unsigned int 4 123u
long 4 132l 123L
unsigned long 4 123ul 123lu 123UL 123LU
}
浮点数
{
float 4 2.2f 2.2F
double 8 2.2 -123.
long double 8 5.5l .5L
}
}
有符号整数
{
补码的存储方式
{
正整数的存储：
{
int a = 123;
unsigned int b = 123;
1）转为二进制
2）补齐位数（前面补0）
3）转为十六进制
4）反向存储
}
负整数的存储：
{
int a = -123;
unsigned int b = -123;
1）转为二进制
2）补齐位数（前面补0）
3）按位取反
4）+1
5）转为十六进制
6）反向存储
}
}
整数的读取
{
有符号类型变量：
int a;
//[!!]
//[!!]
//[!!]
//[?!]
{
?大于8就是负数：
{
1）取出来 !!!
2)转为二进制
3）-1
4）按位取反
5)转为十进制数
6)加负号

			[ff]
			[ff]
			[ff]
			[9f]
			1)9f ff ff ff
			2)10011111 11111111 11111111 11111111  
			3)10011111 11111111 11111111 11111110
			4)01100000 00000000 00000000 00000001
			5)1610612737
			6)-1610612737
		}
		?小于8就是正数：
		{
			1)取出来 ?!!!!!!!
			2)转为十进制正数
			//[ff]
			//[ff]
			//[ff]
			//[0f]
			1）0f ff ff ff
			2）268435455
		}	
	}

	无符号类型变量： unsigned int b = ?????;		
	//[!!]
	//[!!]
	//[!!]
	//[!!]
	{
		1)反着取出来
		2)转十进制
	}
}
整数类型的 字节少的类型赋值给字节多的类型:要补字节
{
	//左边	= 右边
	
	
	右边如果是unsigned类型，则直接补0
	{
		//int = unsigned short
		//unsigned int = unsigned short
		unsigned short a = 0xfabc;
		//[bc]
		//[fa]

		int b = a;
		//[bc]	//[bc]
		//[fa]	//[fa]
		//[00]
		//[00]
		unsigned int c = a;
		//[bc]		//[bc]
		//[fa]		//[fa]
		//[00]
		//[00]
	}

	右边如果是非unsigned类型，则直接补它的符号位
	{
		//int = short
		//unsigned int = short
		short a = 0xfabc;
		//[bc]
		//[fa]
		int b = a;
		//[bc]	//[bc]
		//[fa]	//[fa] 符号位为1则补1
		//[ff]
		//[ff]
		unsigned int c = a;
		//[bc]		//[bc]
		//[fa]		//[fa] 符号位为1则补1
		//[ff]
		//[ff]
		a = 0x1234;
		//[34]
		//[12]
		int d = a;
		//[34]	//[34]
		//[12]	//[12] 符号位为0补0
		//[00]
		//[00]
		unsigned int e = a;
		//[34]		//[34]
		//[12]		//[12] 符号位为0补0
		//[00]
		//[00]
	}
}
整数类型的 字节多的类型赋值给字节少的类型:丢掉后面的字节
{
	//short = int
	//short = unsigned int
	//unsigned short = int
	//unsigned short = unsigned int
	unsigned int a = 0x12345678;
	//[78]
	//[56]
	//[34]
	//[12]
	unsigned short b = a;
	//[78]			//[78]
	//[56]			//[56]
					//[34]
					//[12]
	short c			= a;
	//[78]			//[78]
	//[56]			//[56]
					//[34]
					//[12]
	short d			= a;
	//[78]			//[78]
	//[f6]			//[f6]
					//[34]
					//[12]
	unsigned short e = a;
	//[78]			//[78]
	//[f6]			//[f6]
					//[34]
					//[12]
}

}
标识符原则
{
1）由 字母 数字 下划线 组成
2）数字不能开头
3）不能是关键字
}
强转隐转
{
强转
{
(int)a
int(a)
(int)(a)

	(int*)a
	(int*)(a)
}		
隐转
{
	发生条件
		1) =号左右两边的类型不一样：右边的转成左边的类型
		     int a = 'a';

		2) 多种数据类型参与运算
			a:小于4字节的类型转为int
			b:字节少的转字节多的
			c:精度低的转精度高的
			d:有符号的转无符号的
		std::cout<<'a' + 'a';//结果是194
		std::cout<< 2147483647 + 2147483647;//-2
		std::cout<< 2147483647U + 2147483647;//4294967294
}

}
表达式
{
什么是表达式：有变量，常量，运算符等组成的代码文本，
都有返回结果

int a;//不是表达式,是定义语句
a;//是表达式
a * 23;//是表达式

void f()
{}
f();//不是表达式

int t()
{return 1;}
t();//是表达式

什么是常量表达式：没有变量参与的表达式
a * 23;//不是常量表达式
const int d = 123;
d * 23;//是常量表达式

什么地方用到了常量表达式？
	int arr[长度];  //必须是结果为整数的常量表达式
arr[-3.3];//错的 必须是整数
switch (xxx)
{
case 整数的常量表达式:....break;
case 整数的常量表达式:....break;
case 整数的常量表达式:....break;
}

}
运算符
{
赋值 =
{
等号左边必须是变量
a + 1 = 1;//错
++a = 1;//对
a++ = 1;//错
&a = 1;//错
pa = 1;//对
}
sizeof
{
sizeof(类型): sizeof(char);//1
sizeof(数组名):
{
int arr[4];sizeof(arr);//16
char brr[]={“asdf”,“sdfasdf”,“ss”,""};
sizeof(brr); //16
}
sizeof(字符串字面常量):sizeof(“123456”);//7
sizeof(指针或地址):
{
int arr[4];sizeof(arr+0);//4
char* p = “123456”;sizeof§;//4
char** pp = &p;sizeof(pp);//4 二级指针
void f(int arr[4])
{
sizeof(arr);//4 ！！！
}
char* brr[]={“asdf”,“sdfasdf”,“ss”,""};
sizeof(brr[]); //4 sizeof(char*);
}
sizeof(变量): double a;sizeof(a);//8
double* ab;sizeof(ab);//4
sizeof(表达式): sizeof(‘a’);//1
sizeof(‘a’+true);//4
sizeof(‘a’ > true);// 1
sizeof(4 + 5.5);//8
}
算数 + - * / %
{
浮点数不能%
限定随机数范围：0~99 : rand() % 100
10 ~ 99: rand() % (99+1-10)+10
下标转坐标：
{
X = I % W
Y = I / W
I = X + Y * W
}
}
关系 > >= < <= == !=
{
结果是bool类型
if ( true == 5 ) //假
if ( 5 ) //真
}
逻辑 && || !
{
假 && 不运算了
真 || 不运算了
}
位 & | ^ ~ << >>
{
a & 0xfff00fff
a & 0x8000
a | 0x8000
^ 相同为0，相异为1
~
<< 右边补0
>> 左边补符号位
}
自增自减 ++ –
{
int a = 1;
int b = ++a;//b = 2;

	int c = 1;
	int d = c++;//d = 1;
}
自赋值 += -= *= /= %= &= |= ^= <<= >>=
{
	int a = 1;
	a *= 1 + 2;// a = a * (1 + 2);
}
条件 ?:
{
	C ? A : B;
	C ? "" : 100;//表达式不能编译通过
	C ? true : "";//表达式可以编译通过

	bool a = "123";//a为真
}
逗号 ,
{
	优先级最低
	A ,    B, C ,D;
	a = 1, 2, 3, 4;
	std::cout<< a;//1

		 A, B, C ,D;
	a = (1, 2, 3, 4);
	std::cout<< a;//4
}

}
流程控制
{
分支
{
if-else
switch
}
循环
{
while
do-while
for
}
跳转
{
break
continue
return
goto 不要用
}
}
宏定义
{
要打括号!!!
#define ABC 100
#define DEF (ABC+ABC)
#define 浮点点转整数(a) (int)(a)
}
数组
{
定义： int arr[4];
三种初始化方式：
{
int arr[4] = {1,2,3,4};
int arr[4] = {};
int arr[] = {1,2,3,4,5,6,7,8,9,10};

	arr[4] = {1,2,3,4};//错误的
}
sizeof(数组名);//整个内存的大小

删除K下标:
for (int i = K+1; i <len; ++i)
	arr[i-1] = arr[i];
从K开始往后移：
	for (int i = len-1; i >= K; --i)
		arr[i+1] = arr[i];
(x,y)坐标的数据存入数组的 ？下标
	map[x+y*w]
	map[y+x*w]       map
	0 1 2 3 4        0 2 4 6 8 
	5 6 7 8 9        1 3 5 7 9
	.....

	map[x][y]  int map[W][H];
	map[y][x]  int map[H][W];

}
字符串字面常量
{
常量内存区
“123abc”;
//[31]
//[32]
//[33]
//[61]
//[62]
//[63]
//[00] 结束符

sizeof("123abc");//7
"132abc"的长度为6
大小比较
{
	"123456" <  "abc"
}


char* s[7] = {"星期一","星期二","星期三","星期四","星期","星期五","星期六","星期七"};
char* ss[] = {"□","■","木","口","困"};

for (int i = 0;i < 100; ++i)
{
	std::cout<< ss[ map[i] ];
}

}
地址
{
结果为地址的表达式
{
1）&变量
int a; &a; //int*
int* p; &p; //int**
&&a;//错误的
&(a + 1);//错误的
2）字符串字面常量
“abc”;//
3）数组名
int arr[4];
arr;//
4）指针
5）函数名：
}
地址的类型
{
int a;
&a;// int类型的地址
double b;
&b;//double类型的地址
float arr[100];
arr; //float类型的地址
&arr[6];//float类型的地址
“abcdefg”;//char 类型的地址
long* p;
p;//long类型的地址
main;//返回值是void形参是void 类型的地址
}
地址的输出
{
std::cout<< char 类型的地址;//输出的是字符串
std::cout<< 非 char 类型的地址;//输出的是地址编号
}
地址的运算
{
1)地址 + 整数： 结果是地址
int类型地址0x11223344 + 4 结果为0x11223354
2)地址 - 地址：结果是整数
short类型的地址A 0x11223354 -
short类型的地址B 0x11223344
结果为 (0x11223354 - 0x11223344)/ sizeof(short); 为8
3)地址[整数]：结果是变量
int arr[10];
arr[3];
4) *地址： 结果是变量
int arr[10];
*arr; 等同于 arr[0]

	&地址[0];//右边运算符的优先级要高些
	(int*)地址[0]  ;//一般是错误的
	((int*)地址)[0] ;//对的
}

}
地址的强转
{
(int*)地址
(char*)地址
}
指针
{
//指针就是存储地址的变量
int* p = &a;
p = &a;
p = 1;
sizeof(指针);//都是4
}
const 修饰指针
{
常量指针:可以修改指针的指向，但不能修改指向的地址里面的值
{
int a = 1;
const int p;
p = &a;
p = &a;
//*p = 1;//错误的

	int const * p2;//第二种写法
}
指针常量:不能修改指针的指向，但是可以修改指向的地址里面的值
		 必须初始化
{
	int a = 1;
	int* const p = &a;//初始化
	*p = 11;
	//p = &a;//错误的
}

{
	//符号常量
	const int a = 100;
	//定义一个指针指向这个符号常量
	const int* p = &a;
 }
{
	void f(const int* p)
	{
	}
	int a = 100;
	f(&a);		
}
{
	void f(int* p)
	{
	}
	const int a = 100;
	f(&a);//报错
}
int* p1;
const int* p2;
p2 = p1;//可以的
//p1 = p2;不行的

}
void 指针
{
//可以存储任何类型的地址
void* p;

//*p;  不能直接用void指针
//p[0]; 不能直接用void指针
//p + 1;不能直接用void指针

}
引用
{
{
int a = 1;
int& b = a;//b就是变量a的别名
int* p = &b;//这里的&是取地址运算符呢
p = 2;
}
{
int a = 1;
int p = &a;
int*& q = p;//q是p的别名
*q = 2;//*p = 2;
}

void f(char* p)
{
	p = (char*)malloc(10);
}
void main()
{
	char* p;
	f(p);
	strcpy(p,"123abc");
	std::cout<< p;    //会报错
}



void f(char*& p)
{
	p = (char*)malloc(10);
}
void main()
{
	char* p;
	f(p);
	strcpy(p,"123abc");
	std::cout<< p;   //成功
}



void f(char** p)
{
	*p = (char*)malloc(10);
}
void main()
{
	char* p;
	f(&p);
	strcpy(p,"123abc");
	std::cout<< p;   //成功    
}

}
函数
{
函数的四要素：返回值类型 函数名 形参列表 函数体
函数默认参数： void f(int a, int b = 1, int c = 2){}
函数重载：函数名相同，形参不同的几个函数
{
//只有返回值类型不同的不能称为函数重载
int f(){}
void f(){}

	C++才有函数重载，C语言没有函数重载
}
函数调用方式：
{
	互相调用：
	递归调用： 
}

}
函数指针：指向函数的指针
{
void f()
{
}

void (*p)() = f;
void (*parr[4])() = {f,f,f,f};
p();//调用
(*p)();//调用

int g(int* a)
{
	return 0;
}

int (*pg)(int*) = g;
pg(0);//调用
(*pg)(0);//调用

}
指针函数:函数的返回值类型是指针
{
//普通函数
void f()
{}

//指针函数
int* f2()
{}

}

typedef
{
//给类型取别名，给int类型取别名为INT
typedef int INT;
INT a;//int a

BYTE  字节   typedef char BYTE;
WORD  字	typedef unsigned short WORD;
DWORD  双子   typedef unsigned int DWORD;


//把 void (*)()  这种函数指针的类型取别名为P 
typedef void (*P)();

//定义函数指针
P p;// 等同于  void (*p)(); 

//定义函数指针数组
P parr[4];//等同于 void (*parr[4])(); 


int add(int a, int b)
{
	return a + b;
}


typedef int (*ADD)(int,int);
ADD p1 = add;
ADD p2 = add;
ADD p3[4] = {add,add,0};
p1(1,2);
p2(3,4);
p3[0](5,6);
p3[1](7,8);

}
全局变量
{
写法：写在函数之外
在什么内存：静态内存区
是否自动初始化： 是 自动初始化为0
开辟：进入main函数之前开辟
释放：整个程序结束之后释放

int* p;//int* p = 0;
int a;//int a = 0;
double b;//double b = 0;

void main()
{
}

}
函数的声明
{
//函数的定义:整个程序只能有一个
int add(int a,int b)
{
return a + b;
}

//函数的声明：可以声明多次,可以任何地方
int add(int a,int b);

}
全局变量的声明
{
//全局变量的定义
int a;

//全局变量的声明
extern int a;

//全局变量的定义
int b = 10;

//全局变量的声明
extern int b;

//全局变量的定义
extern int c = 10;

}
头文件
{
#include""和#include<>的区别？
<>是去系统目录下查找，找不到就报错
""是先去项目文件所在的文件夹下查找，如果找不到再去
系统目录下查找，再找不到才报错

相对路径和绝对路径的写法
#include "C:/windows/xxx.h"
#include "xxx.h" 
#include "../xxx.h"  上级目录
#include "include/a/b/xxx.h"  下级目录

什么东西写头文件？宏定义，函数声明，全局变量声明
什么东西写源文件？函数定义，全局变量定义

}
生成可执行程序的步骤
{
预编译
{
宏和#include起作用的时刻。
预编译之后项目只剩下.cpp文件
}
编译
{
声明起作用的时刻。
把每个.cpp编译编译成.obj文件,每个cpp单独编译
调用的每个变量，函数都必须在调用之前找到它的声明或定义
如果没找到，则会报“未声明的标识符”错误
}
链接
{
定义起作用的时刻。
所有的.obj链接成为.exe文件
调用的每个变量和函数都必须在整个项目中找到唯一的定义!
如果没有定义则会报“无法解析的外部符号”错误
如果有多个定义则会报“重定义”错误
}
}
库函数
{
字符串
{
strlen
strcpy
strcat
strcmp
strchr
strstr
}
内存
{
memcpy
memset
}
字符串和整数的转换
{
itoa
atoi
}
时间 #include <time.h>
{
time
ctime_s
GetTickCount #include<windows.h>
}
随机数
{
srand
rand
}
格式化输出
{
sprintf_s
{
%d十进制整数
%s字符串
%c字符
%x十六进制整数
%f浮点数
%.2f小数点后2位的浮点数
}
}
堆内存 #include
{
malloc
{
void* malloc(字节数);
}
free
{
//只能传堆内存的首地址
void free(void* mem);
}
}
数学 #include <math.h>
{
abs
ceil,floor
pow
sin,cos,acos,asin
sqrt
}
其它
{
assert #include <assert.h>
exit
}
}