C++--第五课-继承

最新推荐文章于 2022-03-23 10:59:52 发布
最新推荐文章于 2022-03-23 10:59:52 发布
阅读量289 收藏
点赞数 1
分类专栏： C++编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011371629/article/details/54885039
版权

继承中的几种关系

1. is a的关系

比如说基类狗，派生了肉狗和宠物狗，我们就可以说肉狗是狗，也可以说宠物狗是狗，这就是is a的关系。但是需要注意的是，并非所有的继承都是is a的关系。

2. has a的关系

继承中的权限继承

class Base
{
public:
    int public_i_;      // 外部可访问

protected:
    int protected_i_;   // 内部可访问，外部无法访问，    可继承，子类可访问

private:
    int private_i_;     // 内部可访问，外部不可访问，    不可继承，子类不可访问
};

class A : public Base   // public继承所有的权限都没有发生改变
{
    void SetI()
    {
        protected_i_ = 100;
    }
};

class B : protected Base    // protected 继承会将基类中public的权限改为protected权限
{
    void SetI()
    {
        protected_i_ = 100;
    }
};

class C : private Base  // 将基类中的protected和public权限都改为private权限
{
    void SetI()
    {
        protected_i_ = 100;
    }
};
基类中有默认构造函数的继承中的构造和析构顺序
#include <iostream>

class Base
{
public:
    Base()
    {
        std::cout << "Base::Base()" << std::endl;
    }
    ~Base()
    {
        std::cout << "Base::~Base()" << std::endl;
    }

    int GetNum()
    {
        return num_;
    }

private:
    int num_;
};

class A : public Base
{
public:
    A()
    {
        std::cout << "A::A()" << std::endl;
    }
    ~A()
    {
        std::cout << "A::~A()" << std::endl;
    }
};

int main()
{
    A demo;
    demo.GetNum();

    return 0;
}

这里写图片描述

基类中没有默认构造函数的继承中的构造和析构顺序
#include <iostream>

class Base
{
public:
    Base(int num) : num_(num)
    {
        std::cout << "Base::Base()" << std::endl;
    }
    ~Base()
    {
        std::cout << "Base::~Base()" << std::endl;
    }

    int GetNum()
    {
        return num_;
    }

private:
    int num_;
};

class A : public Base
{
public:
    A() : Base(10)  // 此时会默认的调用基类的默认构造函数，如果基类中没有默认的构造函数时，
        // 那么必须在派生类中的初始化列表中显示的来构造
    {
        std::cout << "A::A()" << std::endl;
    }
    ~A()
    {
        std::cout << "A::~A()" << std::endl;
    }
};

int main()
{
    A demo;
    demo.GetNum();

    return 0;
}
继承中的函数，派生类中没有实现基类的函数方法
#include <iostream>

class Base
{
public:
    Base(int num) : num_(num)
    {
        std::cout << "Base::Base()" << std::endl;
    }
    ~Base()
    {
        std::cout << "Base::~Base()" << std::endl;
    }

    int GetNum() const
    {
        return num_;
    }

private:
    int num_;
};

class A : public Base
{
public:
    A(int num) : Base(0), num_(num) // 此时会默认的调用基类的默认构造函数，如果基类中没有默认的构造函数时，
        // 那么必须在派生类中的初始化列表中显示的来构造
    {
        std::cout << "A::A()" << std::endl;
    }
    ~A()
    {
        std::cout << "A::~A()" << std::endl;
    }

    //int GetNum() const
    //{
    //  return num_;
    //}

private:
    int num_;
};

int main()
{
    A demo(100);
    demo.GetNum();
    std::cout << demo.GetNum() << std::endl;

    return 0;
}

结果是
这里写图片描述

另一种情况是，派生类中实现了基类的函数方法
#include <iostream>

class Base
{
public:
    Base(int num) : num_(num)
    {
        std::cout << "Base::Base()" << std::endl;
    }
    ~Base()
    {
        std::cout << "Base::~Base()" << std::endl;
    }

    int GetNum() const
    {
        return num_;
    }

private:
    int num_;
};

class A : public Base
{
public:
    A(int num) : Base(0), num_(num) // 此时会默认的调用基类的默认构造函数，如果基类中没有默认的构造函数时，
        // 那么必须在派生类中的初始化列表中显示的来构造
    {
        std::cout << "A::A()" << std::endl;
    }
    ~A()
    {
        std::cout << "A::~A()" << std::endl;
    }

    int GetNum() const
    {
        return num_;
    }

private:
    int num_;
};

int main()
{
    A demo(100);
    demo.GetNum();
    std::cout << demo.GetNum() << std::endl;

    return 0;
}

输出结果是
这里写图片描述

基类指针指向派生类对象的函数调用情况
#include <iostream>

class Base
{
public:
    Base(int num) : num_(num)
    {
        std::cout << "Base::Base()" << std::endl;
    }
    ~Base()
    {
        std::cout << "Base::~Base()" << std::endl;
    }

    int GetNum() const
    {
        std::cout << "Base::GetNum()" << std::endl;
        return num_;
    }

private:
    int num_;
};

class A : public Base
{
public:
    A(int num) : Base(0), num_(num) // 此时会默认的调用基类的默认构造函数，如果基类中没有默认的构造函数时，
        // 那么必须在派生类中的初始化列表中显示的来构造
    {
        std::cout << "A::A()" << std::endl;
    }
    ~A()
    {
        std::cout << "A::~A()" << std::endl;
    }

    int GetNum() const  // 这个函数被重写了，也就是把基类中的方法给覆盖了，基类中的方法就不存在了
    {
        std::cout << "A::GetNum()" << std::endl;
        return num_;
    }

private:
    int num_;
};

int main()
{
    Base base(100);
    A a(200);

    Base *pBase = &a;   // 因为 A is Base
    // 宠物狗 Is 狗     对   狗 泛指 宠物狗
    // 狗 Is 宠物狗     错
    std::cout << pBase->GetNum() << std::endl;  // 调用的是 A 中的 Base中的GetNum方法，但是这样很显然不是我们想要的结果
                                                // 这种用基类的指针指向派生类的对象的情况很多

    return 0;
}

输出结果是
这里写图片描述

使用虚函数在继承中函数调用的好处
#include <iostream>

class Base
{
public:
    Base(int num) : num_(num)
    {
        std::cout << "Base::Base()" << std::endl;
    }
    ~Base()
    {
        std::cout << "Base::~Base()" << std::endl;
    }

    virtual int GetNum() const
    {
        std::cout << "Base::GetNum()" << std::endl;
        return num_;
    }

private:
    int num_;
};

class A : public Base
{
public:
    A(int num) : Base(0), num_(num) // 此时会默认的调用基类的默认构造函数，如果基类中没有默认的构造函数时，
        // 那么必须在派生类中的初始化列表中显示的来构造
    {
        std::cout << "A::A()" << std::endl;
    }
    ~A()
    {
        std::cout << "A::~A()" << std::endl;
    }

    int GetNum() const  // 这个函数被重写了，也就是把基类中的方法给覆盖了，基类中的方法就不存在了
    {
        std::cout << "A::GetNum()" << std::endl;
        return num_;
    }

private:
    int num_;
};

int main()
{
    Base base(100);
    A a(200);

    Base *pBase = &a;   // 因为 A is Base
    // 宠物狗 Is 狗     对   狗 泛指 宠物狗
    // 狗 Is 宠物狗     错
    std::cout << pBase->GetNum() << std::endl;  // 调用的是 A 中的 Base中的GetNum方法，但是这样很显然不是我们想要的结果
                                                // ，使用虚函数就可以满足我们的需求，我们在基类中的GetNum前面加上virtual关键字
                                                // 这种用基类的指针指向派生类的对象的情况很多

    return 0;
}

结果是
这里写图片描述
为什么会这样呢？因为使用了虚函数，虚函数用来指明派生类中需要调用的函数，也就是说会在派生类中优先寻找要调用的函数，而不是在基类中寻找这个函数。

虚函数的其它例子
派生类继承并操作了基类中的成员变量

继承了基类中的str_变量，并对其进行了操作，导致内存泄漏，并且在析构的时候重复析构。

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>

class String
{
public:
    String(const char *str = "")
    {
        unsigned int len = strlen(str);
        str_ = new char[len + sizeof(char)];
        strcpy(str_, str);
    }
    ~String()
    {
        delete[] str_;
    }
    String &operator+=(const String &other)
    {
        unsigned int len = strlen(str_) + strlen(other.str_);
        char *temp = new char[len + sizeof(char)];
        strcpy(temp, str_);
        strcat(temp, other.str_);
        delete[] str_;
        str_ = temp;
        return *this;
    }
    String operator+(const String &other)
    {
        String demo;
        demo += other;
        return demo;
    }

protected:
    char *str_;
};

class MyString : public String
{
public:
    MyString(const char *str = "PoEdu")
    {
        unsigned int len = strlen(str);
        str_ = new char[len + sizeof(char)];
        strcpy(str_, str);
    }
    MyString operator+(const MyString &other)
    {

    }

    ~MyString()
    {
        delete[] str_;
        str_ = nullptr;
    }
};



int main()
{
    MyString str;
    //MyString other("Hello");

    return 0;
}
调用基类的构造函数来操作基类的成员变量，而不是在派生类中直接操作基类只能怪的成员变量
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>

class String
{
public:
    String(const char *str = "")
    {
        unsigned int len = strlen(str);
        str_ = new char[len + sizeof(char)];
        strcpy(str_, str);
    }
    ~String()
    {
        delete[] str_;
    }
    String &operator+=(const String &other)
    {
        unsigned int len = strlen(str_) + strlen(other.str_);
        char *temp = new char[len + sizeof(char)];
        strcpy(temp, str_);
        strcat(temp, other.str_);
        delete[] str_;
        str_ = temp;
        return *this;
    }
    String operator+(const String &other)
    {
        String demo;
        demo += other;
        return demo;
    }

protected:
    char *str_;
};

class MyString : public String
{
public:
    MyString(const char *str = "PoEdu") : String(str)
    {
        /*unsigned int len = strlen(str);
        str_ = new char[len + sizeof(char)];
        strcpy(str_, str);*/
    }
    MyString operator+(const MyString &other)
    {

    }

    ~MyString()
    {
        delete[] str_;
        str_ = nullptr;
    }
};

int main()
{
    MyString str;
    //MyString other("Hello");

    return 0;
}

这样虽然保证了只对基类中的成员变量操作一次，但是在析构的时候还是会重复析构。

虚析构函数的使用情形

没有虚析构函数的析构情形

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>


class A
{
public:
    ~A()
    {
        std::cout << "~A()" << std::endl;
    }
};

class B : public A
{
public:
    ~B()
    {
        std::cout << "~B(()" << std::endl;
    }
};

int main()
{
    A *pA = new B();
    delete pA;

    return 0;
}

运行结果如下图所示
这里写图片描述
这样只是调用了基类中的析构函数，并没有调用派生类中的析构函数

有虚析构函数的析构情形

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>


class A
{
public:
    virtual ~A()
    {
        std::cout << "~A()" << std::endl;
    }
};

class B : public A
{
public:
    ~B()
    {
        std::cout << "~B(()" << std::endl;
    }
};

int main()
{
    A *pA = new B();
    delete pA;

    return 0;
}

运行结果如下：
这里写图片描述
这样就会把派生类中的析构函数也调用了。

正确的做法是只需要管理好本类中的成员变量即可，无需管理继承下来的成员变量（其实我觉得在实际的应用中，成员变量应该都是private的，是不需要被子类继承的，只有函数方法才需要被继承下来）
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>

class String
{
public:
    String(const char *str = "")
    {
        unsigned int len = strlen(str);
        str_ = new char[len + sizeof(char)];
        strcpy(str_, str);
    }
    ~String()
    {
        delete[] str_;
    }
    String &operator+=(const String &other)
    {
        unsigned int len = strlen(str_) + strlen(other.str_);
        char *temp = new char[len + sizeof(char)];
        strcpy(temp, str_);
        strcat(temp, other.str_);
        delete[] str_;
        str_ = temp;
        return *this;
    }
    String operator+(const String &other)
    {
        String demo;
        demo += other;
        return demo;
    }

protected:
    char *str_;
};

class MyString : public String
{
public:
    MyString(const char *str = "PoEdu") : String(str)
    {
        length_ = new int(0);
        /*unsigned int len = strlen(str);
        str_ = new char[len + sizeof(char)];
        strcpy(str_, str);*/
    }
    MyString operator+(const MyString &other)
    {

    }

    ~MyString()
    {
        //delete[] str_;
        //str_ = nullptr;   // 正确的方法是不要去管理基类中的成员变量，只需要管理本类中的成员变量即可
        delete length_; // 只需要管理本类中的length变量就可以了
    }

private:
    int *length_;
};


int main()
{
    //MyString str;
    //MyString other("Hello");

    return 0;
}

这样就保证了程序的正确运行。

虚函数的调用
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>

class String
{
public:
    String(const char *str = "")
    {
        unsigned int len = strlen(str);
        str_ = new char[len + sizeof(char)];
        strcpy(str_, str);
    }
    String(const String &other)
    {
        unsigned int len = strlen(other.str_);
        str_ = new char[len + sizeof(char)];
        strcpy(str_, other.str_);
    }

    ~String()
    {
        delete[] str_;
    }
    String &operator+=(const String &other)
    {
        unsigned int len = strlen(str_) + strlen(other.str_);
        char *temp = new char[len + sizeof(char)];
        strcpy(temp, str_);
        strcat(temp, other.str_);
        delete[] str_;
        str_ = temp;
        return *this;
    }
    String operator+(const String &other)
    {
        String demo(*this);
        demo += other;
        return demo;
    }

    friend std::ostream &operator<<(std::ostream &os, const String &other)
    {
        os << other.str_;
        return os;
    }

protected:
    char *str_;
};

class MyString : public String
{
public:
    MyString(const char *str = "PoEdu") : String(str)
    {

    }
    MyString operator+(const MyString &other)
    {
        MyString temp(*this);
        temp += other;  // 因为从基类中继承了一个 += 操作符
        temp += "---------PoEdu";
        return temp;    // 此时在返回的时候会调用拷贝构造函数，如果没有实现拷贝构造函数，
                        // 那么就会出现浅拷贝的情况，导致程序运行错误，所以我们必须手动实现拷贝构造函数
    }
};


int main()
{
    MyString str("I Love ");
    String *pString = &str;
    std::cout << str + ("Mark") << std::endl;
    std::cout << *pString + ("Mark") << std::endl;

    return 0;
}

运行结果
这里写图片描述

继承中的虚析构函数

基类中的析构函数不是虚析构函数，而是普通函数的情况：

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>

class A
{
public:
    ~A()
    {
        std::cout << "~A()" << std::endl;
    }
};
class B : public A
{
public:
    B() : A()
    {
        demo_ = new int(0);
    }
    ~B()
    {
        std::cout << "~B()" << std::endl;
        delete demo_;
    }

private:
    int *demo_;
};

int main()
{
    A * pA = new B();
    delete pA;

    return 0;
}

运行结果是：
这里写图片描述
从结果上可以看出，在delete的时候，只是调用了基类中的析构函数，并没有调用派生类中的析构函数，那么，如何能让派生类中的析构函数也被调用呢？请看下面的情况！！！
基类中的析构函数是虚析构函数的情况：

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>

class A
{
public:
    virtual ~A()
    {
        std::cout << "~A()" << std::endl;
    }
};
class B : public A
{
public:
    B() : A()
    {
        demo_ = new int(0);
    }
    ~B()
    {
        std::cout << "~B()" << std::endl;
        delete demo_;
    }

private:
    int *demo_;
};

int main()
{
    A * pA = new B();
    delete pA;

    return 0;
}

运行结果：
这里写图片描述
关于继承的构造和析构顺序的总结：
一般的继承体系的类
基类构造 基类成员构造 子类构造
子类析构 基类成员析构 基类析构

继承中的虚继承

著名的菱形继承

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>


class A
{
public:
    int a_;
};

class B : public A
{
public:
    int b_;
};

class C : public A
{
public:
    int c_;
};

class D : public B, public C
{
    // a_ b_ c_，并且a_是两个
    // 我们称这种继承方式为菱形继承
};

int main()
{
    D d;
    d.a_;

    return 0;
}

此时在编译的时候就会出错，如下所示：
这里写图片描述
但是，我们也是可以访问的

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>


class A
{
public:
    int a_;
};

class B : public A
{
public:
    int b_;
};

class C : public A
{
public:
    int c_;
};

class D : public B, public C
{
    // a_ b_ c_，并且a_是两个
    // 我们称这种继承方式为菱形继承
};

int main()
{
    D d;
    d.B::a_;
    d.C::a_;

    return 0;
}

指明要访问哪个基类中的变量，就不会出现编译错误了。
这样虽然解决了编译错误的问题，但是我们不需要这样的情况，我们只需要一份变量就可以了，那么这样该怎么解决呢？我们可以通过虚继承来解决这个问题！！！

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>


class A
{
public:
    int a_;
};

class B : virtual public A
{
public:
    int b_;
};

class C : virtual public A
{
public:
    int c_;
};

class D : virtual public B, virtual public C
{
    // a_ b_ c_，并且a_是两个
    // 我们称这种继承方式为菱形继承
};

int main()
{
    D d;
    d.a_;

    return 0;
}

此时编译也就可以通过了。

继承中的纯虚函数
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>


class Animal
{
public:
    virtual void Cry() = 0; // 纯虚函数，无需实现，需要子类来实现
};

class Dog : public Animal
{
public:

};

int main()
{
    Dog dog;    // 此时编译不能通过，因为没有实现基类中的纯虚函数

    return 0;
}
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>


class Animal
{
public:
    virtual void Cry() = 0; // 纯虚函数，无需实现，需要子类来实现
};

class Dog : public Animal
{
public:
    void Cry()
    {

    }
};

int main()
{
    Dog dog;    // 当实现了基类中的纯虚函数后，就能实例化对象了


    return 0;
}
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>

// 纯虚函数 不能实例化
class Animal
{
public:
    virtual void Cry() = 0; // 纯虚函数，无需实现，需要子类来实现(强制性的进行实现)
};

class Dog : public Animal
{
public:
    void Cry()
    {

    }
};

class A : public Dog
{

};

int main()
{
    Dog dog;    // 当实现了基类中的纯虚函数后，就能实例化对象了
                // 只要有纯虚函数的类，我们称之为抽象类，抽象类是无法实例化的
    A a;        // 此时A类就可以实例化，因为Dog类中已经实现了纯虚函数

    return 0;
}
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>

// 纯虚函数 不能实例化 是其它类的基类 经常用来作为接口使用 接口是用来进行解耦的
// 接口
// 没有任何的数据成员，只是把函数名列出来
class Animal
{
public:
    virtual void Cry() = 0;     // 纯虚函数，无需实现，需要子类来实现(强制性的进行实现)
    virtual void Jump() = 0;    // 跳的接口
};

class Dog : public Animal
{
public:
    void Cry()
    {

    }
};

class A : public Dog
{

};

int main()
{
    Dog *dog = new A(); // 用来指向子类
    dog->Cry();

    return 0;
}
艺术人生666
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
中国大学MOOC程序设计与算法（三）：C++ 笔记：继承
m0_45314773的博客
01-31 180
继承和派生 继承和派生的概念 继承：在定义一个新的类B时，如果该类与某个已有的类A相似(指的是B拥有A的全部特点)，那么就可以把A作为一个 基类，而把B作为基类的一个 派生类(也称子类) 。 派生类是通过对基类进行修改和扩充得到的。在派生类中，可以扩充新的成员变量和成员函数。 派生类一经定义后，可以独立使用，不依赖于基类。 派生类拥有基类的全部成员函数和成员变量，不论是private、protected、public 。 在派生类的各个成员函数中，不能访问基类中的private成员 ...
C++学习笔记 ---继承
星星leslie的博客
07-06 567
继承继承中的对象模型 继承中的对象模型 问题：从父类继承过来的成员，哪些属于子类对象中 //父类（基类） class Base { public: int m_A; protected: int m_B; private: int m_C; }; //子类（派生类） class Son: public Base { public: int m_D; }; void test01() { Son s1; cout << sizeof(s1) << endl; } 打印结果为
C++ 学习笔记（18）继承访问属性细说
Wonz
07-31 377
继承是多态的基础。 #include&lt;iostream&gt; using namespace std; class Base{ private: int x; }; class D : public Base{ //子类公有继承父类 public: int y; }; void main(){ cout&lt;&lt;sizeof(Base)&lt;&lt;endl; ...
C++: 继承
miaomiaoAmlp的博客
01-07 693
继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类(子类), 被继承的称为基类(父类)。 子类继承了父类除构造函数和析构函数之外所有的成员变量和成员方法, 不论是公有的还是私有的、保护的. 相当于除了构造和析构函数之外所有成员全都拷贝一份到子类中. (但能不能访问和有继承到是另一回事.) 继承的形式: class base {}; class a:public base { //
c++继承
m0_64837135的博客
03-23 297
继承是面向对象三大特性之一。 有些类与类之间存在一些特殊的关系，例如： 有一个动物类，猫与狗都是属于动物，都有动物的共性，也有自己的个性。 我们发现，定义这些类时，下级的成员除了拥有上一级的共性之后，还有自己的特性。 这个时候我们就可以考虑利用继承的技术，减少重复的代码。 //继承的好处：减少重复的代码。//语法：class 子类 : 继承方式 父类 //子类 也称为 派生类 //父类 也称为 基类 //派生类的成员包括两部分： //一类是从基类继承过来，一类是自己增加的成员。 //从基类继承过...
c++第8单元第5课C++-Test-8-5.rar
06-22
在本课程中，我们将深入探讨C++编程语言的第8单元第5课。"C++-Test-8-5.rar"这个压缩包包含了与这一课相关的资料，主要聚焦于C++的一些核心概念和实践应用。标签"C++"明确指出了讨论的主题，即C++编程语言。下面，...
c++第8单元第18课C++-Test-8-18.rar
最新发布
06-24
【标题】：“C++第8单元第18课：C++-Test-8-18.rar” 这是一份关于C++编程语言的学习资料，重点聚焦于第8单元的第18课内容。从标题来看，我们可以推测这可能是一个测试或者练习集合，用于检验或巩固学习者在C++第8...
c++第8单元第3课C++-Test-7-31.rar
06-22
【标题】"C++第8单元第3课：C++-Test-7-31" 涉及的内容主要是C++编程语言的学习，尤其是针对第八单元的深入理解。在这个测试中，我们可能将探讨C++的一些核心概念和高级特性。 【描述】"c++第8单元第3课C++-Test-7-...
c++第8单元第9课C++-Test-8-9.rar
06-22
在本课程中，我们将深入探讨C++编程语言的第8单元第9课，主题围绕着"C++-Test-8-9"。这个压缩包文件包含了相关的学习材料和可能的测试练习，旨在帮助我们掌握C++的关键概念和技术。下面，我们将详细讨论其中涵盖的...
c++第8单元第16课C++-Test-8-16.rar
06-24
这个压缩包文件"C++第8单元第16课C++-Test-8-16.rar"包含了一个名为"Test-8-16"的子文件夹，这通常意味着它可能包含了与该课程相关的练习、测试或项目代码。C++是一种强大的、面向对象的编程语言，广泛应用于系统...
public 函数_c++派生类的构造函数与析构函数
weixin_39821378的博客
11-28 252
#include#includeusing namespace std;//派生类的构造函数class Base1{public: Base1(int i) { b1 = i; cout << "Base1构造函数被调用" << endl; } void Print() const{ cout << b1 << e...
C#构造函数里的base和this的区别
zdhlwt2008的博客
10-09 589
实例一:   父类的构造函数总是在子类之前执行的。既先初始化静态构造函数，后初始化子类构造函数。 public class BaseCircle { public BaseCircle() { Console.WriteLine(" no arguments base constructor!!!"); }
C++class A:public Base1,public Base2的先后调用基类顺序
qq_42423354的博客
12-18 2928
看程序写结果 #include <iostream> using namespace std; class Base1 { public: Base1(int i){cout<<"调用基类Base1构造函数:"<<i<<endl;} }; class Base2 { public: Base2(int j){cout<<"调用基类Base2构造函数:"<<j<<endl;} }; class A: publ
C#中base关键字的几种用法
weixin_34292287的博客
06-13 264
base其实最大的使用地方在面相对性开发的多态性上，base可以完成创建派生类实例时调用其基类构造函数或者调用基类上已被其他方法重写的方法。 例如： 2.1关于base调用基类构造函数 public class A { public A() { Console.WriteLine("Build A"); ...
关键字-protected使用总结
CPriLuke的博客
03-02 697
为了更好说明，首先定义一个基类如下，里面包含三种不同访问类型的成员函数class Base{ public: void pub_mem() {} protected: void prot_mem() {} protected: void priv_mem() {} };①派生类成员或友元可访问基类受保护成员，但只能通过派生类访问；struct Derv:public Base{ //1....
C#中base关键字的几种用法:base()
热门推荐
橙-极纪元-cplvfx-JJY.Cheng
10-09 2万+
base其实最大的使用地方在面相对象开发的多态性上，base可以完成创建派生类实例时调用其基类构造函数或者调用基类上已被其他方法重写的方法。 例如： 2.1关于base调用基类构造函数 public class A { public A() { Console.WriteLine("Build A"); } } ...
第一课：C过渡到C++--之二
艺术人生的专栏
12-21 2212
函数重载C++的函数重载机制为我们程序员提供了很大的便利，但同时也会带来一些问题，这时我们会发现，当我们调用重载函数时，会出现编译不通过的现象，还有给别人提够函数接口也会出现一些问题。#include "stdafx.h" #include <iostream>// 以输出不同类型的参数为例的重载函数 void MyPrintf(char c) { printf("%c\n", c); }v
走进计算机世界--计算机科学
艺术人生的专栏
08-28 1346
1. 程序是什么？ 程序等于数据加算法，是为了实现特定目标或者解决特定问题，使用计算机语言编写的命令序列的集合。2. 程序由什么构成？ 程序是由指令和数据构成。3. 什么是机器语言？ 机器语言又被称为低级语言或者二进制代码语言，是计算机中的CPU能够直接解读的数据。4. 运行中的程序存储在什么位置？ 运行中的程序存放在内存中。5. 什么是内存地址？ 内存地址存储在RAM中的特定位置
小说阅读器
艺术人生的专栏
10-19 1239
先把代码贴上吧，还有好多地方要完善，以后有时间再一点儿一点儿的完善吧// 加这个全局变量为了避免一个bug，由于时间紧张， //暂时就先这么来避免，有时间一定找到这个bug bool g_bNovalNameNeedFind = true;// 枚举小说内部信息的类型 typedef enum _tagInfoType { Noval_Name, // 小说名字
C++编程语言ISO-IEC 14882第三版（2011）：规范与技术细节
ISO-IEC 14882是C++编程语言的国际标准，第三版发布于2011年9月1日。该标准详细规定了C++语言的语法、语义、内存模型以及对象模型，适用于信息科技领域中的程序设计。以下是对标准的一些关键知识点的概述： 1. **...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值