C与C++的故事
C++可以说是C衍生而来却比C高级很多倍,也可认为是与C毫无瓜葛的一门新语言(这个角度可能学得更快)。
字符转int: http://www.cnblogs.com/bluestorm/p/3168719.html
C语言综合项目实战 3.13相片(70 76 80)
零 再提提与C的关系
1.c++中添加c库
extern "C"
{
include <stdio.h>
}
2.对C扩展了:①命名空间 ②引用 ③函数重载 ④默认参数
⑤参数列表
①作用:防止变量冲突(避免全局变量重名,避免使用库函数的时候出现与库中的变量名冲突)-多人开发时类似于c语言中的static文件作用域
②变量的别名不占用内存空间(从本质上说引用是编译器对指针的一种包装Type *const p) 定义:数据类型 &引用名 = 变量名 （定义引用的时候必须要赋值）;函数内部可通过const修饰避免改变引用对象值：
int a = 10;//或const int a =10；
const int &b = a;
③函数名相同,参数个数或类型或顺序不同
④形参赋值 从右到左连续默认;
⑤参数列表初始化:Data(int d=20, int n=10):data(d),number(n)//类外实现,创建对象的时候执行,声明时用默认参数,实现时不需要写
3.类与结构体区别(关键字):①类中可以用变量和函数,结构体只能有变量②类默认权限是私有的,结构体是公有
*const修饰常量替代#define定义的宏常量更有效率(裸机开发)
一 何为面向对象
结构体类似C++等语言的类，成员不能放函数，但能放函数指针，C++面向对象思路类似C语言的结构体
微信截图_20170405092523.png
复杂宏分析
大疆14年笔试.png
Paste_Image.png
C++相关文件后缀:.cpp, .cc, .cxx, .hpp, .h
1.0构造(析构)函数:与类名相同,没有返回值,创建对象后系统自动调用（可以在构造方法中初始化成员）,系统可默认生成一个不带参数;构造方法重载一般类内声明类外实现,如果是在类的内部声明和实现c++中会认作为内联函数;析构:无返回值无参数,当对象销毁时系统自动调用
1.1拷贝构造函数:浅(系统也可自动生成):Data(Data &d);深拷贝:不但要拷贝对象本身的空间,还要拷贝对象成员指向的额外空间（堆空间）
1.2.成员属性和方法:
1.3.private: //私有，对外隐藏 在类的外部不可以通过类的对象来使用的成员-在类的内部使用无限制
2.1 继承(代码复用):原有基础添加新功能(方法-属性) class Child: public Parent
4.析构方法先调用子类，再调用父类</br>
虚继承.png
2.2 三种不能继承情况
2.3 多继承:class 子类 :继承方式 父类， 继承方式 父类 （如果没有写继承方式默认为私有继承）;构造方法调用顺序与继承顺序有关,与参数列表无关;环状多继承;出现多个副本的时候可以用虚继承来避免多个父类对象
2.4 重写与覆盖
3.0 多态(联系继承,纯/虚函数)
虚函数(父类要有):virtual void show();//修饰基类成员函数(派生同名类指向问题解决)[指向基类的指针在操作它的多态类对象时，会根据不同的类对象，调用其相应的函数，这个函数就是虚函数]
子类重写父类普通函数和虚函数区别-虚表查看方法
1.如果一个类中有虚函数那么这个类的对象中包含一个虚表（虚表是在对象的最前面）
2.类中的虚函数指针会存储在虚表中，
3.如果在子类中有与父同名,同参函数,在虚表中会把父类虚函数覆盖
4.如果子类有个与父类不同的虚函数，虚函数指针会存储在父类虚函数表后面
纯虚函数与抽象类:纯虚函数:virtual void show()=0;//不需要函数体,有纯虚函数的类-->抽象类(抽象类是不能被创建对象);继承时子没把父(抽象类)中纯虚函数全部实现也是抽象类
3.0
3.1
4.0 指针与智能指针
指针变量是用于存储地址（切记）,定义时为其赋初值NULL即为（void *）0，也就是空指针，这样做
是为了防止野指针;长度:在32位系统当中是4个字节，跟指向的类型空间是没有关系的
int i = 10; //变量i的地址表示 &i;
int *p = &i; //定义一个指针变量p,p指向int数据类型空间，指向空间的值为10
int i = 12
char *p = "hello";
int *p1 = &i;
sizeof(p) = 4 sizeof(p1) = 4
错误使用
//1.错误引用指针，未初始化指针，非法引用
int *p;
*p = 50;
//2
一维数组注意:定义a[10]是取不到a[10]这个值的!原因:使用时下标最大值为定义时元素个数减1
数组越界,可以访问但里面值非自己所想
数组本身同指针关系
int a[5] = {1,2,3,4,5};
sizeof(a) = 20 //5*sizeof(int);
a 与 &a
a :数组的首地址，也是首元素地址
&a:整个数组的首地址
自己查阅资料
int *p;
p=a;
printf("%p\n",&p1[10]);//0xbfe10e52，输出第n位地址只能用&符号取地址？
第一个元素地址可用量种方法获得p=&a[0]或p=a;数组名作参数传递时会变为普通指针（4字
节），失去常量特性，可自增减操作，可被修改
指针与二维数组关系：（（p+1）+2）表示取a[1][2]内容，*p表示取a[0][1]内容，因为p
是指向整型变量指针；p++表示p的内容加1，即p中存放的地址增加一个整型量的字节数2，从而使p指
向下一个整型量a[0][1]
假设：a = 0x23; 那么&a = 0x23
a+1 = 0x27 &a+1 = 37
思考：有数组short a[5] = {1,2,3,4,5};假设a = 0x56;请问下列的值为多少
a &a a+1 &a+1 a+3 *(&a[0]) a[3]+7 *(a+2)
0x56 0x56 0x58 0x60 0x5c 1 11 3
*(&a[0]) == a[0]
-级指针与一维数组
char ch[6] = "hello"; //ch = 0x22
char *p = NULL; //防止野指针
char *p1= NULL;
p = ch;
p1 = &ch[2];
printf("p+2 = %p",p+2); //ch + 2 = 0x24
printf("p1 - p = %p",p1 - p); //结果是2
结论：
指针相减是针对数组（才有意义）而言，相减结果为地址间的元素的个数(公式：(p1 -
p)/sizeof(数据类型));
指针相加是无意义的
思考：int a[10] = {12,354,53,645,34,4,6};
int *p = NULL,*p1 = NULL;
p = &a[1];
p1 = &a[9];
p1-p = 8 (&a[5])-(&a[0]) = 5
p1-p:(p1-p)/sizeof(int) = 32/4 = 8
(&a[5])-(&a[0]):(&a[5])-(&a[0])/sizeof(int) = 20/4 = 5
Paste_Image.png
二维数组
二维数组：一维数组的数组，由相同的类型组成，有固定长度
二维数组模型：
数据类型 数组名[m][n] = {值};
数据类型:与变量类型是一致的；char short int long float double unsigned(char
short int long)
数组名：命名规则跟变量命名的规则是一致的
m：大数组个数
n：每个大数组中小数组元素个数
int arr[2][3]; //定义了一个二维数组，大数组2，每个大数组中小数组元素个数3，可以存
六个int 数据；未初始，值是随机
int arr[][50];//不允许，无法确定个数
int arr[][3] = {1,2,3};//系统可以初始化分配空间大小，大数组1，每个大数组中小数组
元素个数3
思考:int arr[][4] = {2,3,4,5,6,5}; //int arr[2][4] = {2,3,4,5,6,5}; arr[1][3]
=0
int arr[3][4] = {{1,2,3,4},{3,4,5,6},{5,6,7,8}};//初始化并赋值
int arr[2][4] = {2,3,4,5,6,5} == int arr[2][4] = {{2,3,4,5},{6,5,0,0}};
char ch[3][4] = {"he","hi","boy"};
ch[0] == "he";ch[1] == "hi";ch[2] == "boy";
ch[1][2] = '\0';
深度剖析二维数组
char ch[3][4] = {"he","hi","boy"};
ch &ch
ch:数组首元素的首地址
&ch：整块数组的首地址
假设上面：ch = 0x14;
%p %p %p %d
ch +１ &ch+1 ch[0] ch[2] ch + 2 a[1][1]+7 ??
0x18(v) 0x38 0x14(v) 0x1c(v) 0x1c(v) 112(v)
0x15 0x20(v) 0x14+0x8
5.0 类的友元函数:可访问类中所有成员
友元类:B类中声明A类为友元类,A类中所有成员函数都是B类友元函数,所有成员函数可访问B类中所有成员
实现:
二 如何设计我的类和对象
静态成员与方法
3.静态属性和方法-[java没指针(处处有指针)]
C++允许我们把一个或多个成员声明为属于某个类而不仅仅属于该类
的对象（没创建对象也可以调用方法，使用相关属性,还可让有关数据在该）
类所有对象间共享）
创建:static(3个作用:1.隐藏全局变量 2.用来控制变量的存储方式和可见性 3.默认初始为0) 静态方法能访问所有成员吗？
静态成员与静态函数
类对象大小计算:非静态成员属性+在虚表中指针大小
static关键字(全局 局部 可同名,作用域不同(类也有作业域))
声明为静态的好处:
存储(静态存储区) 生命周期最长
静态成员(保存在数据段)
private(class中的):
static int data;
int main(){Data d;//栈中}
int Data:data = 10;//静态成员属性初始化(定义在类外,未赋值不占用空间)
类的静态成员属性先于类的对象存在,公有的话可通过类名使用,被所属类所有对象共用
例:Data d;
Data::data;//属性公有可通过类名使用
Data mD;
d.data = 123;
cout<<mD.data<<endl;//输出123
静态方法 5.5 9:40左右视频
先于对象存在,静态方法中不包含this指针,不能调用非静态成员,可调用先于对象存在的成员和局部变量(和类无关的)
公有方法可被所属类名和类的对象直接调用
单例模式(截图 5.5 10:20) 用途:类传输数据(数据类)-传输:静态 单实例(堆 首地址-所有数据)
获取对象 单例可以被延迟初始化
public: 单例类可以被集成，他的方法可以被覆写
Data(){} 单例可以继承类，实现接口，
static Data *sharedData()
{
if(instance == NULL)
{
instance = new Data();//堆空间
}
应用:整个应用只能创建一个对象,对象间数据传递
总结:或许最重要的是，单例类可以被用于多态而无需强迫用户只假定唯一的实例。举个例子，你可能在开始时只写一个配置，但是以后你可能需要支持超过一个配置集，或者可能需要允许用户从外部从外部文件中加载一个配置对象，或者编写自己的。你的代码不需要关注全局的状态，因此你的代码会更加灵活。
三 库的使用-STL和Boost
STL---标准模板类库 --www.cplusplus.com
string ---
template < class charT,
class traits = char_traits<charT>, // basic_string::traits_type
class Alloc = allocator<charT> // basic_string::allocator_type
> class basic_string;
typedef basic_string<char> string;
list
template < class T, class Alloc = allocator<T> > class list;
vector
template < class T, class Alloc = allocator<T> > class vector; // generic template
set ----存储的数据必须是唯一的， 自动排序
template < class T, // set::key_type/value_type
class Compare = less<T>, // set::key_compare/value_compare
class Alloc = allocator<T> // set::allocator_type
> class set;
map
template < class Key, // map::key_type
class T, // map::mapped_type
class Compare = less<Key>, // map::key_compare
class Alloc = allocator<pair<const Key,T> > // map::allocator_type
> class map;
