3、C++快速入门

参考书籍：

C++程序设计教程_第二版_钱能    //篇幅较少，适合快速学习

C++ Primer Plus  第六版  中文版   //篇幅较大，讲的非常详细

C++一般必须包含的头文件是#include <iostream>；导入的命名空间是：using namespace std;

1、访问控制，类和对象

class是对struct的扩展，含有数据成员和成员函数

访问控制：private、public、protected，其中private声明的数据成员仅供类内部函数使用，public声明的类外部程序也可使用，默认的属性是private

int a：int是类型，a是变量

Person per ：Person是类，per是对象

（在类中通过”this->数据成员”表示类内成员）

2、程序结构

　　类定义（.h）/类实现（.cpp）

　　如果在类中仅声明了函数，在类外怎么实现？void 类名::函数名(参数){函数体}

　　A类实现Person类，其提供.h和.cpp,在A.h中仅声明类，其中类成员函数也仅声明，在A.cpp中通过类名::函数名来实现成员函数;B类实现main，B不关心Person类怎么实现，只需要#include <person.h>

　　

　　命名空间

　　如果main文件中include多个h文件，同时这些h文件中存在同名的函数，其返回值和参数都一样，这个时候在h和其对于的cpp中把全部或者部分同名的函数使用namespace 名字A｛｝扩起来，在main中通过“名字A::同名函数名”还区分

eg：Person.h

　#include <stdio.h>

　　namespace A{

　　class Person{

　　private:

　　　　char *name;

　　　　int age;

　　　　char *work;

　　public:

　　　　void setName(char *name);

　　　　int setAge(int age);

　　}

　　void printVersion(void);

　　}

Person.cpp

　　#include <stdio.h>

　　#include "person.h"

　　namespace A{

　　void Person::setName(char *name)

　　｛

　　　　this->name = name;

　　｝

　　int Person::setAge(int age)

　　{

　　　　this->age = age;

　　　　return 0;

　　}

　　void printVersion(void)

　　{

　　　　printf("Person111111");

　　}

　　}

Main.cpp

　　#include <stdio.h>

　　#incldue "person.h"

　　using A::Person;//加上这句后，main中类的声明前面可以不加“命名空间：：”，这句话把A::Person放入global namespace，以后可以使用Person来表示A::Person

　　//using namespace A;作用同是把A空间全部导入，注意在导入多个命名空间的时候，如果命名空间中存在同名同参函数，在使用的时候还是要加上“命名空间：：”来区分，但在导入的时候不会出现问题

　　int main(int argc,char **argv)

　　{

　　　　A::Person per;//声明命名空间后，类的声明需要在前面加上“命名空间：：”

　　　　A::printVersion();

　　　　return 0;

　　}

3、重载、指针和引用

　重载：函数名系统，参数不同（类型、数量、顺序）

　指针和引用：引用就是别名，引用定义时必须初始化，且其只能引用变量，不能是常量：int a；int &b = a//b就是a的引用，b所指的内存和a一样；C++中经常使用引用来传递参数，引用传递的是地址，仅四字节，否则如果参数是对象，则传递对象耗费空间大

　引用举例：

　int add（int &b）

　　｛

　　　　b = b +1;

　　　　return b;

　　｝

　　调用add：

　　int a = 99；

　　add(a);

　　cout<<a<<endl;//引用会导致a变量被修改

4、构造函数

　　声明变量时调用构造函数

　　eg：Person per(变量1，变量2)；//会调用构造函数void  Person(变量1，变量2){};

　　注意：调用默认构造函数是通过Person per，而不是Person per();其会被理解为一个函数声明，返回值是Person

　　Person *per4 = new  Person;

　　Person *per5 = new  Person();

　　Person *per6 = new  Person[2];

　　Person *per7 = new  Person("list",18,"student");

　　Person *per8 = new  Person("list",18);

　　如果在构造函数中通过new分配了空间，应该在析构函数中delete掉，否则只能等到主函数推出后才能被回收,析构函数在实例化对象被销毁之前的瞬间被调用，比如在一个函数中会声明这个实例化对象，在函数执行完退出时销毁该实例化对象。但是如果在函数中是通过new来实例化一个对象的时候（Person *per4 = new  Person;），函数退出时per4 指针所指向的对象不会被销毁，其析构函数不会被调用，只能通过delete per4来销毁或者等整个main程序退出的时候才能回收空间，但次数不会调用对象的析构函数。

　　eg：PersonPerson(){

　　　　　　this->name = new char[10];

　　　　}

　　　　~PersonPerson(){

　　　　　　if(this->name)

　　　　　　　　delete this->name;

　　　　}

　　对象有默认的无参构造函数、无参析构函数、还有一个默认的拷贝构造函数，即在声明一个实例化对象的时候提供的参数是对象：Person per("zhangsan",18);Person per2(per);即per2使用per来初始化的，这个时候调用的构造函数就是默认的拷贝构造函数，per2的属性内容和per一样，共享地址空间，如果per内存被释放，per2在执行释放的时候也会再次释放该内存，存在风险，所以需要提供自己的拷贝构造函数：

eg：Person（Person &per）

｛

　　this->age = per.age;

　　this->name = new char[strlen(per.name)+1];

　　strcpy(this->name,per.name);

｝

　　函数中定义的静态实例化对象在函数退出的时候不会被销毁；再次进入函数的时候也不会被创建，其还存在

　　全局对象、main中局部对象、子函数中局部对象中的构造函数执行顺序：1、全局对象构造函数->main中局部对象构造函数->子函数中局部对象构造函数

　　如果在类A中声明了成员类对象B，则在实例化A对象的时候先调用B的构造函数，在调用A的构造函数；析构函数是先调用A的析构，在调用B的析构，即析构函数的调用顺序与构造函数的调用顺序相反（不管A中有多少个对象）

　　如果类中定义了有参构造函数，则系统不会在提供无参的构造函数，这时候在声明无参对象时会出错，因为已经没有无参构造函数了

5、静态成员和友员函数

　　static修饰的成员属于类，不属于对象，其仅有一份，通过“类名::成员名”访问，并且私有的static成员仅能被static函数访问

　　并且static成员必须在类外面定义和初始化：int Person::cnt =0;在类中仅是声明，在类外给其分配空间和初始化

　　被类设置为的友员函数可以访问本类的私有成员：eg：在类中通过“friend 函数声明”来声明该类的友员函数

6、操作符重载-通过类外函数实现

　　通过操作符重载可以实现通过“+”、“-”等符号实现对象的加减

　　class Point｛

　　private:

　　　　　　int x;

　　　　　　int y;

　　friend Point operator+(Point &p1,Point &p2);

　　｝

　　Point operator+(Point &p1,Point &p2)

　　{

　　　　Point n;

　　　　n.x = p1.x + p2.x;

　　　　n.y = p1.y + p2.y;

　　　　return n;

　　}

　　int main(int argc,char **argv)

　　{

　　　　Point p1(1,2);

　　　　Pont p2(2,3);

　　　　Point sum = p1+p2

　　}

　　来实现Point p(1,2);p++;++p;

　　注意：下面两个需要在类中声明为友员，目的是为了访问类的私有成员，如果成员是公有的，则不需要声明为friend；

　　Point operator++(Point &p)//++p，这里的重载函数返回了个Point对象，返回的时候会根据p值来调用构造函数Point（const Point &p）来构造一个对象，如果不使用这个返回的对象，立马会调用其析构函数并且被销毁；这样一个构造和析构过程比较浪费资源，如果把返回值声明为Point& operator++（Point &p）,这样就不会新声明一个对象了，直接返回传入的p的引用，但需要注意返回引用和返回值的时候不能影响程序的执行结果

　　{

　　　　p.x += 1;

　　　　p.y += 1;

　　　　return p;

　　}

　　Point operator++(Point &p,int a)//p++，在main中也可以通过operator++(p,0)来调用

　　{

　　　　Point n;

　　　　n=p

　　　　p.x += 1;

　　　　p.y += 1;

　　　　return n;

　　}

　　使用的时候p++；++p就可以

　　

　　对cout的重载，eg：Point m,n;cout<<m<<n;//cout<<m返回的就是cout，是对cout的引用这样才能cout<n;

　　ostream& operator<<(ostream &o,Point p)//这个函数也可以在main中通过“operator<<(cout,p)”调用

　　{

　　　　cout<<"("<<p.x<<","<<p.y<<")";//<<endl这里的endl表示回车

　　　　return o;

　　}

7、操作符重载-通过类内函数实现

　　把上面6中这些外部重载的函数移到类内部就可以，通过减少参数，因为类内部函数在被对象调用的时候，这个对象就是一个参数eg：p1.operator+(p2)

　　现在执行m = p1+p2表示为m=p1.operator+(p1);

　　注意：cout输出不能在类内部实现，因为"p.operator<<"其第一个参数是Point类型，而函数的第一个参数数ostream类型

　　重载“=”：Person& operator=(const Person& p)//如果不重载“=”，那么p = p1，会是的p里面的变量会和p1里面的变量指向同一片内存（注意：Point p=p1执行的是拷贝构造函数）

　　　　　　{

　　　　　　　　if(this == &p)

　　　　　　　　　　return *this;

　　　　　　　　this->age = p.age;

　　　　　　　　if(this->name){

　　　　　　　　　　delete this->name;

　　　　　　　　}

　　　　　　　　if(this->work){

　　　　　　　　　　delete this->work;

　　　　　　　　}

　　　　　　　　this->name = new char[strlen(per.name)+1];

　　　　　　　　strcpy(this->name,per.name);

　　　　　　　　this->work = new char[strlen(per.work)+1];

　　　　　　　　strcpy(this->work,per.work);

　　　　　　　　return *this;

　　　　　　}

8、访问控制和继承

　　class Person{};

　　calss Student:public Person{};//Student类继承Person类

　　基类成员在派生类中的访问控制属性

　　 　　　　基类访问属性　　public                protected                 private

　　继承类型

　　public　　　　　　　　　　public           protected　　　　　　隔离

　　protected　　　　　　　　protected       protected 　　　　　　隔离

　　private　　　　　　　　　　private        private　　　　　　　隔离

　　（无论那种继承方式，在派生类内部使用父类时并无发别；仅影响外部代码对派生类的使用和派生类的之类）

　　说明：1、派生类不能访问基类的私有成员；

　　　　　2、派生类可以通过protected或者public的成员函数访问私有成员；

　　　　   3、派生类可以访问protected成员，其他外部代码不可以（protected成员外界不可访问）；

　　　　　4、派生类继承到的成员可以修改成员的权限（protected可以修改为public、private，但是private成员不能被修改权限）

　　　　　　（eg：在派生类中通过“public:

　　　　　　　　　　　　　　　　　　　　using 父类名::父类成员名或者函数名”可以修改成员变量和函数的权限）

Base &b2=d1;// 子类对象当父类对象

　 b2.print(); // 调用父类函数

9、多重继承

　　派生类（子类）有多个父类（基类）

　　eg：

　　class Sofa{};

　　class Bed{};

　　class Sofabed:public Sofa,public Bed{};//这里如果不写继承方法，则默认的是private继承

　　

　　虚拟继承：D继承A和C，这个时候在D中怎么访问A和C同名的函数呢：1、d.A::同名函数（）；2、把A和C中同名的部分抽象出来一个类B，A和C通过virtual来虚继承，对于虚继承的A和C，在子类D中只会有一份B中的成员（class A：virual public B）

10、构造顺序

　　A、先父类（基类）后子类（派生类）

　　B、对于父类：先虚拟基类后一般基类

　　C、对于子类：先对象成员，后自己的构造函数

11、多态(使用相同的调用方法，对于不同的对象会调用不同的类里面的实现的函数，根据传入的对象类型自己识别该类型，并调用类型的函数)

　　eg：反面例子，都是调用父类的eating函数

　　class Human｛

　　public：

　　　　void eating(void){cout<<"use hand to eat"<<endl;}

　　｝

　　class Englishman:public Human｛

　　public：

　　　　void eating(void){cout<<"use knife to eat"<<endl;}

　　｝

　　class Chinese:public Human｛

　　public：

　　　　void eating(void){cout<<"use chopsticks to eat"<<endl;}

　　｝

　　void test_eating(Human & h)

　　{

　　　　h.eating();

　　}

　　int main(int argc,char **argv)

　　{

　　　　Human h;

　　　　Englishman e;

　　　　Chinese c;

　　　　test_eating(h);

　　　　test_eating(e);

　　　　test_eating(c);

　　}

　　执行结果：

　　use hand to eat

　　use hand to eat

　　use hand to eat

　　

　　修改test_eating函数让其能够自己判断传入的参数是属于那个类，并调用该类的eating函数（通过虚函数）

　　class Human｛

　　public：

　　　　virtual void eating(void){cout<<"use hand to eat"<<endl;}

　　｝

　　class Englishman:public Human｛

　　public：

　　　　virtual  void eating(void){cout<<"use knife to eat"<<endl;}//这里的virtual可以不用写，因为父类是virtual，其子类覆盖后也是virtual函数

　　｝

　　class Chinese:public Human｛

　　public：

　　　　virtual  void eating(void){cout<<"use chopsticks to eat"<<endl;}//这里的virtual可以不用写，因为父类是virtual，其子类覆盖后也是virtual函数

　　｝

　　//void test_eating(Human * h)

　　void test_eating(Human & h)//使用指针或者引用来使用对象时，才有多态,如果是test_eating(Human h)则即使使用虚函数也是调用父类的eating，因为这个时候如果调用的是test_eating(e),这个e被强制转换成Human类，会把对象里面那个指向自己虚函数表的那个指针丢掉

　　{

　　　　h.eating();

　　}

　　int main(int argc,char **argv)

　　{

　　　　Human h;

　　　　Englishman e;

　　　　Chinese c;

　　　　test_eating(h);

　　　　test_eating(e);

　　　　test_eating(c);

　　}

　　执行结果：

　　use hand to eat

　　use knife to eat

　　use chopsticks to eat

　说明：对于非虚函数，在编译时已经确定好调用的是那个类的函数；对于虚函数，在运行是才能确定

　　　　对于有虚函数的类，其对象里面有个指针，指向虚函数表（虚函数表里面也是一些地址，指向虚函数）；调用虚函数的时候，是通过这个指针来调用虚函数

　　　　（通过sizeof（对象），可以发现有virtual函数和无virtual函数的对象大小不一样）（虚函数表里面出来有虚函数地址外，还有对象所属类和基类的相关信息）

　　静态成员函数、内联函数、构造函数都不能是虚函数，析构函数一般都声明为虚函数（举例如下）

　　int main(int argc,char **argv)

　　｛

　　　　Human* h =new Human;

　　　　Englishman* e = new Englishman;

　　　　Chinese *c = new Chinese;

　　　　

　　　　Human *p[3] = {h,e,c};

　　　　int i;

　　　　for(i = 0;i<3;i++)

　　　　{

　　　　　　p[i]->eating;

　　　　　　delete p[i];

　　　　}

　　｝

　　如果析构函数不是虚函数：执行结果：（在上面的各个Human、Englishman、Chinese的类中添加析构函数）

　　use hand to eat

　　~Human()

　　use knife to eat

　　~Human()

　　use chopsticks to eat

　　~Human()

　　如果析构函数是虚函数：执行结果

　　use hand to eat

　　~Human()

　　use knife to eat

　　~Englishman()

　　use chopsticks to eat

　　~Chineseman()

　　

　　重载：函数参数不同，名字相同，不可设为虚函数(当重载函数的返回值是本类的指针或者引用时可以设置为虚函数，能实现多态)；

　　覆盖：函数名字、函数参数和返回值都相同，可设为虚函数；

12、类型转换

　　隐式类型转换：double d = 100.1;int i =d;//double转int,i = 100;

　　　　　　　　　char *str = "100.ask";int *p = str;//char * 转为int *

　　(隐式类型转换有编译器来实现，其并不一定能猜测出代码的意图，编译的时候会出现warning)

　　显示类型转换：A、强制类型转换：double d = 100.1;int i =(int)d;

　　　　　　　　　　　　　　　　　  char *str = "100.ask";int *p =(int *) str;

　　　　　　　　　B、动态转换：dynamic_cast<type-id>(expression):该运算符把expression转换成type-id类型的对象。Type-id必须是类的指针、类的引用或者void*，如果tpe-id是类指针类型，那么expression也必须是一个指针；如果type-id是一个引用，那么expression也必须是一个引用；

　　void test_eating(Human & h)

　　{

　　　　Englishman *pe;

　　　　Chinese *pc;

　　　　h.eating();

　　　　if(pe = dynamic_case<Englishman *>(&h))

　　　　　　cout<<"This human is Englishman"<<endl;

　　　　if(pe = dynamic_case<Chinese*>(&h))//这里的&h是取址

　　　　　　cout<<"This human is Chinese"<<endl;

　　}

　　int main(int argc,char **argv)

　　{

　　　　Human h;

　　　　Englishman e;

　　　　Chinese c;

　　　　test_eating(h);

　　　　test_eating(e);

　　　　test_eating(c);

　　}

　　执行结果：

　　use hand to eat

　　use knife to eat

　　This human is Englishman

　　use chopsticks to eat

　　This human is Chinese

　　　　　　　　　C、静态转换：static_cast<type-id>(expression)编译器在编译的时候已经决定好怎么转换

　　下行转换会存在隐患eg：Englishman *pe = static_case<Englishman *>(&h);编译能成功，下行转换存在风险  但如果使用Englshman类的方法是程序会崩溃

　　　　　　　　　　　　　Englishman *pe = static_case<Englishman *>(&g);编译不能成功　

　　　　　　　　　　　　　Chinese*pe = static_case<Chinese*>(&g);编译能成功，没问题，上行转换没问题

　　　　　　　　    D、使用reinterpret_cast从新解析转换（同c语言风格的强制类型转换）：double d = 100.1;int i =reinterpret_cast<int>(d);

　　　　　　　　　E、通过const_case去掉变量const或者volatile属性：const char *str = "100ask"; char *str2 = const_case<char *>(str);

注意：动态转换用于多态场合，即：必须有虚函数，引用转换的时候需要用到虚函数表里面的类和基类信息来转换

　　　 主要用于类层次间的上行转换(派生类转换成基类)和下行转换(基类转换成派生类)，还可以用于类之间的交叉转换

　　　在类层次间进行上行转换是，dynamic_cast和static_cast的效果是一样的；在进行下行转换时，dynamic_cast具有类型检查的功能，比static_cast更安全

　　eg：

　　class Guangximan:public Chinese｛

　　public：

　　　　virtual  void eating(void){cout<<"use chopsticks to eat,I come from guangxi"<<endl;}

　　｝

　　void test_eating(Human & h)

　　{

　　　　//Englishman& pe = dynamic_case<Englishman&>(h);执行的时候会出错，转换失败，引用没指向一个实体，肯定出错

　　　　Chinese & pc = dynamic_case<Chinese&>(h);

　　　　Guangximan &pg = dynamic_case<Guangximan &>(h);

　　　　h.eating();

　　}

　　int main(int argc,char **argv)

　　{

　　　　Guangximan g;

　　　　test_eating(g);//Guangximan类转换成Human类就是上行转换，进入函数后Human类转换成Chinese和Guangximan 就是下行转换

　　}