C++ 小甲鱼视频总结

第一讲：C++语言面向对象的的特性：封装，抽象，继承，多态。

第四讲：读取文件的类ifstream,写入文件的类ofstream，都是来自一个头文件fstream。

　　　　常见的几种打开模式：

　　　　ios::in --打开一个可读文件

　　　　ios::out --打开一个可写入文件

　　　　ios::binary -- 以二进制的形式打开一个文件

　　　　ios::app --写入的所有数据将被追加到文件的末尾

　　　　ios:: trunk --删除文件原来已存在的内容

第六讲：方法（函数）的重载只是对参数的不同来区别不同的方法，对于返回值的不同是方法的覆盖。

第七讲：对于string对象的一些常用的方法：

　　　　截取字符串：substr（）；

　　　　比较字符串：compare（）；

　　　　添加字符串：insert（）；

　　　　替换字符串：replace（）；

　　　　搜索字符串：find（）；

第八讲：数据的地址在内存中存储时是对齐的，操作系统是32位就以4k的方式对齐，64位的就是以8k的方式对齐。比如int型的地址存放在0123的位置，然后定义了char的存放到45的位置（内存中字符是以ASCII形式存放），在定义一个int型的则存放到9 10 11 12的位置，为了cup更方便运算。定义的指针变量必须和变量的类型一样。

第九讲：在指针中*有两个作用：1、用于创建指针变量，并不是解引用的意思  int *temp; 2、用于解引用  *temp。 void *temp2；空指针就是没有被申明的指针。

第十一讲：

//结构
struct  studdnt
[
  string name;
  char sex;
  int age;    //定义不同的数据类型
}

第十三讲：对于联合（union）和结构差不多，区别是联合一个对象只能赋一个变量的值。对于枚举（enum）我们通常可以用到swich中

int main()
{
    enum student
    {
        xiaodang, xiaokai, xiaowen   //这里的xiaodang相当于0
    };
    student std;
    std = xiaokai; //这里的std相当于1
    switch (std)
    {
    case xiaodang: cout << "找到小党了"; break;
    case xiaokai: cout << "找到小开了"; break;
    case xiaowen: cout << "找到小文了"; break;
    default: cout << "什么都没有找到"; break;
    }
    return 0;
}

 第二十四讲：虚方法（virtual）

class Pet
{
public:
    virtual void play();      //父类定义为虚方法，否则输出的就是000，现在输出的是子类的方法
};
void Pet::play()
{
    std::cout << " oooo " << std::endl;
}

class Dog:public Pet
{
public:
    Dog(std::string dogName);
    ~Dog() {};
     void play();
private:
    std::string dname;

};
Dog::Dog(std::string dogName)
{
    dname = dogName;
}
void Dog::play()
{
    std::cout << dname << "is play bot" << std::endl;
}


class Cat :public Pet
{
public:
    Cat(std::string catName);
    ~Cat() {};
    void play();
private:
    std::string cname;

};
Cat::Cat(std::string catName)
{
    cname = catName;
}
void Cat::play()
{
    std::cout << cname << "is play dd" << std::endl;
}
int main()
{
    Pet *pot1 = new Dog("dahuang");
    Pet *pot2 = new Cat("xuexue");
    pot1->play();
    pot2->play();
    return 0;
}

第二十五讲：抽象方法（abstract）

当这个方法是必不可少时，但是又不想在基类里面实现时，我们就可以用抽象方法。那只需要在我们上面的例子中，在基类的play虚方法后面加上一个“=0”而不用实现，就可以了，这样我们就告诉编译器，不需要去基类里面寻找这个方法的实现。 

第二十九讲：对于多继承

class Person
{};

class Anmial
{};

class Teacher:public Person,public Anmial  //多继承
{};

 第三十四讲：关于动态内存管理：当我们new一个对象时，这个对象是存储在堆上的，不会自动清理，需要我们使用delete来清理我们申请的内存，同时把指针赋值位NULL。而我们不用new创建一个对象时，这个对象的生命周期只存在于这个函数的结束。系统会自动清理。

class Person
{
public:
    Person(std::string name);
    virtual void play();     //这里定义虚函数，为了在子类方法覆盖时，调用不到子类的方法

protected:
    std::string pName;
};
Person::Person(std::string name)
{
    this->pName = name;
}
void Person::play()
{
    std::cout << pName << "play games" << std::endl;
}

class Anmial : public Person
{
public:
    Anmial(std::string thename,std::string thegame);
    void play();
protected:
    std::string Agame;
};
Anmial::Anmial(std::string thename, std::string thegame):Person(thename)  //继承父类的构造函数时，参数应该一致
{
    this->Agame = thegame;            //这里当我们的类和父类的变量名一致时，我们可以用this指针来区分，像这里可以不用this
}
void Anmial::play()
{
    std::cout << pName << " like play " << Agame << std::endl;
}

int main()
{
    Person *Prn = new Anmial("xiaohua", "cod16");   //使用new创建一个对象
    Prn->play();
    delete Prn;     //清理堆里内存
    Prn = NULL;    //指针清空

    return 0;
}

第三十五讲：关于动态数组  

int main()
{
    int count;
    std::cout << "输入整数" << std::endl;
    std::cin >> count;

    int *temp = new int [count];    //定义动态数组
    for (int i = 0; i < count; i++)
    {
        temp[i] = i + 1;
        std::cout <<"第"<<i<< "个数字尸"<< temp[i] << std::endl;
    }

    delete[]temp;   //释放内存
    return 0;
}

 第三十八讲：强制转换

int main()
{
    Company *cop = new Company("APPLE", "Iphone");
    TecCompany *Tcop = dynamic_cast<TecCompany*>(cop);//这里如果dynamic_cast<TecCompany*>(cop)转换没有成功，则得到的结果为NULL
    if (Tcop == NULL)                                //当然我们也是可以用（TecCompany*）cop直接转换的，但是这样会存在风险
    {
        cout << "内存为空" << endl;
        return 0;
    }
    Tcop->start();

    delete Tcop;
    cop = NULL;
    Tcop = NULL;
    return 0;
}

第四十五讲：模板

函数模板

template<class T>  //其中class并不是类的意思，而是我们约定俗称的
void foo(T a)            //T代表了不确定的类型
{
    //do something
}

调用的时候可以直接像普通函数那样调用，也可以写成  foo<int>(a); 

类模板

template<class T>
class Student
{
    student();
    void foo(T &a, T &b);
};

举个例子：

template<class T>
class Stack
{
public:
    Stack(int size = 100);  //如果不指定大小，则默认100
    ~Stack();
    void push(T value);
    T pop();

protected:
    int size;
    T *date;         //定义一个指针
    int sp;

};

template<class T>
Stack<T>::Stack(int size)  //注意泛型的类名的后面要增加一个T
{
    this->size = size;
    date = new T[size];
    sp = 0;
}

template<class T>
Stack<T>::~Stack()
{
    delete[] date;    //释放指针指向的内存
}

template<class T>
void Stack<T>::push(T value)
{
    date[sp++] = value;
}

template<class T>
T Stack<T>::pop()
{
    return date[--sp];
}
int main()
{
    Stack<int> sta;
    sta.push(1);
    sta.push(2);
    sta.push(3);
    cout << sta.pop() << endl;
    cout << sta.pop() << endl;
    cout << sta.pop() << endl;
    return 0;
}

当需要多个数据类型的时候我们只需要增加数据类型即可  template<class T,class U> ，实例化时我们只需要填入我们需要的类型即可 MyClass<int, double> mc; 

第四十八讲：容器

向量：vector，定义 vector<string> vct; 

#include<vector>
using namespace std;
int main()
{
    vector<string> vct;
    vct.push_back("HELLO ");
    vct.push_back("WORLD!");
    vector<string>::iterator iter = vct.begin();  //iterator是迭代器

    while (iter != vct.end())
    {
        cout << *iter << endl;       //输出hello world
        ++iter;
    }
    return 0;
}