1.每种数据类型所占内存大小
2.每种数据的取值范围
常量：字面值。
变量：值可以改变的量。
变量定义：类型名 变量名 [ = 变量初始值 ];
标识符：变量等等的取名。
保留字：系统保留的特殊用途的字。
整数，包含所有进制。
小数。
1.字符常量
‘a’ , ‘b’ ,‘1’
2.转义字符
‘\n’ ‘\’ ‘’’ …
3.字符变量
char c = ‘a’ ;
printf("c1=%c, c2=%c\n",c1,c2);
printf("c1=%d, c2=%d\n",c1,c2);
printf("%f",num);
知识点： ASCII
printf("hello world!");
/*
* 区分'a' "a"
* 字符串结尾多出来一个转义字符'\0'，作为结束符
*
*/
注：Ctrl+F5 调试
Ctrl+F9 断点
Ctrl+F10下一断点
Shift +F9 添加监视
Ctrl Alt M +1 调用内存1（调试-窗口-内存-内存1）
定义变量之后才能使用，一般是要赋初值的，否则会出错。
不同数值类型的数据一起运算的的时候，系统尝试将变量类型统一。
类型转换从：
char ， short ---->int ----> unsigned ----> long ----> double <-----double <----float
范围：由小变大。（隐式转换）
算数运算符 + - * 、 %（取余）
关系运算 <, <=, ==，>, >=,!=
逻辑运算符 ！， &&， ||
位运算符 <<, >>, ~, |, ^, &
赋值运算符 =
条件运算符 ? :
逗号运算符 ,
指针运算符 * ， &
求占字节运算符 sizeof()
强制类型转换符 (类型名)
成员变量运算符 . , ->
下标运算符 []
其他 …
一般形式： （类型名）（表达式）
int a=1;
double b=(int) a;
总结：两种数据类型转换
都有精度损失或者溢出的风险。
前++
后++
只适用于整型变量。
前置返回类型
int func( int a , int b);
int func( int a , int b)
{
return a+b;
}
后置返回类型
auto func( int a, int b)->int ;
auto func( int a, int b)->int
{
return a+b;
}
提示：一般一个函数写个几十到几百行就行，别太多，难以阅读。
将简短且常用的函数定义为内联函数，代码在编译时被编译器会自动替换函数为函数体。
inline int myfunc()
{
return 1;
}
void func(int a, int b){
a+b;
}
int func(int a, int b){
return a+b;
-返回指针
int * func(int b)
{
int a=b;
return &a;//函数一结束a就被释放，巨大隐患。
}
int & func()
{
int a=0;
return a;//函数一结束a就被释放，巨大隐患。
}
void func(int &a ,int &b)
{
int temp=a;
a=b;
b=temp;
}
关于修饰符：修饰符是从变量的旁边从右向左阅读
因此：
太难解释了，总之就是
先导：
形参的三种传值方式：
int add(int a, int b)
{
cout<<"a的地址:"<<&a<<std::endl;
cout<<"b的地址:"<<&b<<std::endl;
}
int main()
{
int c=1,d=2;
cout<<"c的地址:"<<&c<<std::endl;
cout<<"d的地址:"<<&d<<std::endl;
add(c,d);
}
int add(int *a, int *b)
{
cout<<"a指向的地址:"<<a<<std::endl;
cout<<"a的地址:"<<&a<<std::endl;
cout<<"b指向的地址:"<<b<<std::endl;
cout<<"b的地址:"<<&b<<std::endl;
}
int main()
{
int e=1,f=2;
int *c=&e，*d=&f；
cout<<"c的地址:"<<&c<<std::endl;
cout<<"d的地址:"<<&d<<std::endl;
add(c,d);
}
int add(int &a, int &b)
{
cout<<"a的地址:"<<&a<<std::endl;
cout<<"b的地址:"<<&b<<std::endl;
}
int main()
{
int c=1,d=2;
cout<<"c的地址:"<<&c<<std::endl;
cout<<"d的地址:"<<&d<<std::endl;
add(c,d);
}
综上，值传递需要消耗时间去复制实参到形参。
指针传递和引用传递是直接调用实参，效率更高。
函数参数带const
void func(const int & a)
{
a=1;//不能通过a修改实参的值，报错。
//引用传递，速度更快。
}
迭代器仅仅是用来遍历容器的，若在遍历容器时，对容器进行修改，例如删除、添加的操作，会导致迭代器失效。
禁止迭代器使用时修改容器容量！
C语言风格：
double b=10.1;
int a =(int) b;
C++四种强制类型转换
通用形式：
//强制类型转换名<type> (express);
double f=10.2;
int a= static_cast<int> (f);
//类似
int b=(int ) f;
class A{};
class B :public A{};
B b;
A a= static_cast<A> (b);
dynamic_cast ：运行时类型识别和检查
const_cast ：用于去除指针或者引用的const属性，编译时检查。
在这里插入代码片
1.并发
多个任务同时进行。（边听音乐边写作业，听音乐和写作是两不同的活动，但是同事进行。）
早期计算机只有一个CPU，为了同时间执行多个任务，我们规定在一定的时间间隔内执行程序，这样就可以在宏观上达到并行执行程序，但实际微观上是隔很短的时间不停的切换执行程序，这样看起来就像很多程序同时执行一样。
2.可执行程序
盘上的一个文件，window上是 .exe 结尾的文佳 ，Linux上面是 文件权限为 -rwxrw-r–的文件。
3.进程
可执行程序运行起来就是一个进程，总之就是一个运行的程序的过程就是进程。
4.线程
请先记住两件事：
总结：
5.学习心得
戒骄戒躁，慢慢来。
1.多进程并发
多个程序同时运行。进程通讯三种方式：管道通讯、消息通讯和共享内存。
2.多线程并发
单个进程创建多个线程。线程通信代价更小，同一个进程的线程是共享地址空间，因此多线程并发开销更小。但是由于共享地址空间，数据一致性问题凸显。
3.总结
多线程并发的优缺点：
优点：线程启动速度更快，更轻量级，系统资源开销更少，执行速度更快。
缺点：使用起来有难度，要小心处理数据一致性问题。
C++11的线程库可以跨平台，使用起来更加方便。
#include <iostream>
#include <thread>
using std::cout;
using std::endl;
void myprint()
{
cout << "我的线程开始执行了！" << endl;
//.......
cout << "我的线程执行结束了。" << endl;
return;
}
int main()
{
std::thread mytobj(myprint);//myprint作为构造函数参数
mytobj.join();//main主线程等待子线执行
//mytobj.detach();
//主线程不会等待子线程
cout << "main主函数执行结束了！" << endl;
return 1;
}
（1）thread
一个类。构造函数的参数是一个可调用对象（此处可调用对象就是函数myprint）作为thread构造函数的实参来构造这个thread对象。
（2）join
阻塞函数，让main主线程等待子线程执行。（主线程结束，子线程会被强制结束）
（3）detach
分离函数，让main主线程不等待子线程执行。
（4）joinable
bool res=mytobj.joinable();//true为调用过。
判断某个线程是否调用过join或者detach函数。
1.用类来创建线程
#include <iostream>
#include <thread>
using std::cout;
using std::endl;
class TA {
public:
//重载“（）”运算符
void operator ()() {
cout << "TA::operator()开始执行了" << endl;
//...
cout << "TA::operator()执行结束了" << endl;
}
};
int main()
{
TA ta;
std::thread myTObj(ta);
myTObj.join();
cout << "main主函数执行结束了！" << endl;
return 1;
}
一些危险的操作：
/*
*使用detach后，当main函数执行结束后，
*很可能子线程还在访问主线程里面的*my_i，
*这个时候my_i早已被释放，子线程仍
*旧使用被销毁的ny_i，产生不可预料的
*后果。
*/
#include <iostream>
#include <thread>
using std::cout;
using std::endl;
class TA {
public:
int& m_i;
TA(int& i):m_i(i){}
void operator ()() {
cout << "mi1的值为：" << m_i << endl;
cout << "mi2的值为：" << m_i << endl;
cout << "mi3的值为：" << m_i << endl;
cout << "mi4的值为：" << m_i << endl;
cout << "mi5的值为：" << m_i << endl;
cout << "mi6的值为：" << m_i << endl;
cout << "mi7的值为：" << m_i << endl;
cout << "mi8的值为：" << m_i << endl;
cout << "mi9的值为：" << m_i << endl;
}
};
int main()
{
int my_i = 6;
TA ta(my_i);
std::thread myTObj(ta);
myTObj.detach();
//main函数执行太快，延缓main，让线程函数执行
for (int i = 0; i < 1000000; ++i) {
int q;
q = 1;
}
cout << "main主函数执行结束了！" << endl;
return 1;
}
2.用lambda表达式来创建线程
#include <iostream>
#include <thread>
using std::cout;
using std::endl;
auto myLamThread = [] {
cout << "我的线程开始执行了" << endl;
//...
cout << "我的线程执行结束了" << endl;
};
int main()
{
std::thread myTObj(myLamThread);
myTObj.join();
cout << "main主函数执行结束了！" << endl;
return 1;
}
1.要避免的陷阱1
主线程已经运行结束，资源已经释放，但是子线程仍然在调用主线程资源。
#include <iostream>
#include <thread>
using std::cout;
using std::endl;
using std::thread;
void myPrint(const int& i, char* pmyBuf)
{
cout << i << endl;
cout << pmyBuf << endl;
return;
}
int main()
{
cout << "main主线程开始执行" << endl;
int mvar = 1;
int& mvary = mvar;
char myBuf[] = "this is a test!";
thread myTObj(myPrint, mvar,myBuf);
myTObj.detach();
cout << "main主函数执行结束了！" << endl;
return 1;
}
2.要避免的陷阱2
传递的参数隐式转换时，还未来的及转换转换，资源就被释放。
#include <iostream>
#include <thread>
#include <string>
using std::cout;
using std::endl;
using std::thread;
using std::string;
void myPrint(const int& i, const &string pmyBuf)
{
cout << i << endl;
cout << pmyBuf << endl;
return;
}
int main()
{
cout << "main主线程开始执行" << endl;
int mvar = 1;
int& mvary = mvar;
char myBuf[] = "this is a test!";
thread myTObj(myPrint, mvar,myBuf);
myTObj.detach();
cout << "main主函数执行结束了！" << endl;
return 1;
}
总结：
1.线程id概念
每个线程对应这不同的id。
使用：std::this _thread::get_id()、
2.临时对象构造时机抓捕