C++快速入门

2022-09-17

字数统计: 1.2k字 | 阅读时长≈ 5分

C++中的explicit关键字只能用于修饰只有一个参数的类构造函数, 它的作用是表明该构造函数是显示的, 而非隐式的, 跟它相对应的另一个关键字是implicit, 意思是隐藏的,类构造函数默认情况下即声明为implicit(隐式).

析构器不用手动调用。

重载只能在同一个类中，子类不能重载从父类继承来的方法。

类的静态方法、属性其实就是作用域为类的静态变量、函数。

virtual ：运行是确定，而不是编译时。

int main()
{
    Alinmal *pig = new Dog("peiqi"); // 1.如果没有virtual：在编译是确定，因为new的接收指针类型是父类（Alinmal）eat方法就会用父类里面的（尽管Dog子类中已经重写了eat方法） 2.如果加了virtual：就是在运行是才确定，new的是Dog子类，所以eat用Dog子类重写后的方法。 3.因为是运行是确定所以会耗多余的CPU，所以不要滥用virtual关键字声明没必要的方法。
    pig->eat();
    pig->sleep();

    Alinmal *cat = new Cat("jiafei");
    cat->eat();
    cat->sleep();

    return 0;
}

如果自己声明析构函数，一定要加上virtaul声明为虚函数，不然会造成子类的析构函数不会被调用的情况。

为ostrem添加 << 运算符重载

虚继承

Student和Teacher类都从Person类继承，那么TeacherStudent类的对象就会出现两个Person类的实例（有两个name属性）。

Teacher类和Student类是虚继承Person类，都拥有不了Person的拷贝。

1.如果基类虚继承了别的类，子类需要自己真正去继承这个类。（构造函数的时候调用这个类的构造函数）

副本构造器

重载赋值运算符 = ，当遇到指针是拷贝指针指向地址的内容。

运算符重载函数最后返回这个对象的引用，这样就可以连续赋值。

以上的if判断：a = a 不需要处理。类的运算符 = 重载只在对象已经被实例化时拷贝可行。在对象实例化的时候同时赋值就不行。

对象实例化时同时赋值我们的重载 = 就不起作用了，此时编译器会在类中找一个叫做副本构造器的东西。

副本构造器其实就是一个接收一个此类对象引用的普通构造器，可以在类中定义重载多个参数不同的构造器。

C语言强制类型转换的缺陷

dynamic_cast<MyClass*>(value)：安全的强制转换，C++经常用到。

链接

每个文件就有一个独立的翻译单元，只有具有外链接的作用域才能被其他翻译单元看见。

普通的函数、变量、模板和命名空间都有外链接。

范型编程

函数模板

类模板

template <class T> // 这是一个类模板
class Stack
{
public:
    Stack(int size = 100);
    ~Stack();
    int push(T item);
    T pop();
    void list();
private:
    int size;
    int sp;
    T *stack;
};

template <class T> // 这是一个类模板的方法定义
Stack<T>::Stack(int size)
{
    stack = new T[size];
    this->size = size;
    sp = 0;
}

template <class T>
Stack<T>::~Stack()
{
    delete [] stack;
}

template <class T>
int Stack<T>::push(T item)
{
    if (sp < size)
    {
       stack[sp] = item;
       sp++;
    }
    else
    {
        std::cout << "stack is full!" << std::endl;
        return -1;
    }

    return 0;
}

template <class T> 
void Stack<T>::list()
{
    for(int i = 0; i < sp; i++)
    {
        std::cout << "stack[" << i << "] = " << stack[i] << std::endl;
    }
}

template <class T>
T Stack<T>::pop()
{
    if (!sp)
    {
        std::cout << "stack is empty!" << std::endl;
        return -1;
    }

    sp--;
    return stack[sp];
}

int main()
{
    Stack<int> *obj = new Stack<int>(10); // 告诉编译器根据模板生成int类型的类， 并实例化一个对象给obj指针
    obj->push(12);
    obj->push(124);
    obj->list();

    obj->pop();
    obj->list();
    
    Stack<double> *obj1 = new Stack<double>(10); // 告诉编译器根据模板生成double类型的类， 并实例化一个对象给obj1指针
    obj1->push(4687.546);
    obj1->push(12487412.67);
    obj1->list();

    obj1->pop();
    obj1->list();
    
    delete obj;
    delete obj1;
    return 0;
}