C++深度解析教程笔记12ok-继承，继承的构造与析构，同名覆盖

于 2024-07-16 21:28:20 发布
阅读量503 收藏 2
点赞数 16
文章标签： c++ 笔记 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35429166/article/details/139031617
版权

C++深度解析教程笔记12

第43课 - 继承的概念和意义

在这里插入图片描述
在这里插入图片描述

实验-类的组合

#include <iostream>
#include <string>

using namespace std;

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

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

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

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

class Computer
{
    Memory mMem;
    Disk mDisk;
    CPU mCPU;
    MainBoard mMainBoard;
public:
    Computer()
    {
        cout << "Computer()" << endl;
    }
    void power()
    {
        cout << "power()" << endl;
    }
    void reset()
    {
        cout << "reset()" << endl;
    }
    ~Computer()
    {
        cout << "~Computer()" << endl;
    }
};

int main()
{   
    Computer c;
    
    return 0;
}
/*
Memory()
Disk()
CPU()
MainBoard()
Computer()
~Computer()
~MainBoard()
~CPU()
~Disk()
~Memory()
*/

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

实验-类的继承

#include <iostream>
#include <string>

using namespace std;

class Parent
{
    int mv;
public:
    Parent()
    {
        cout << "Parent()" << endl;
        mv = 100;
    }
    void method()
    {
        cout << "mv = " << mv << endl;
    }
};

class Child : public Parent
{
public:
    void hello()
    {
        cout << "I'm Child calss!" << endl;
    }
};

int main()
{   
    Child c;
    
    c.hello();
    c.method();
    
    return 0;
}
/*
Parent()
I'm Child calss!
mv = 100
*/

在这里插入图片描述
在这里插入图片描述

实验-子类与父类的构造顺序

#include <iostream>
#include <string>

using namespace std;

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

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

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

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

class Computer
{
    Memory mMem;
    Disk mDisk;
    CPU mCPU;
    MainBoard mMainBoard;
public:
    Computer()
    {
        cout << "Computer()" << endl;
    }
    void power()
    {
        cout << "power()" << endl;
    }
    void reset()
    {
        cout << "reset()" << endl;
    }
    ~Computer()
    {
        cout << "~Computer()" << endl;
    }
};

class HPBook : public Computer
{
    string mOS;
public:
    HPBook()
    {
        mOS = "Windows 8";
    }
    void install(string os)
    {
        mOS = os;
    }
    void OS()
    {
        cout << mOS << endl;
    }
};

class MacBook : public Computer
{
public:
    void OS()
    {
        cout << "Mac OS" << endl;
    }
};

int main()
{   
    HPBook hp;
    
    hp.power();
    hp.install("Ubuntu 16.04 LTS");
    hp.OS();
    
    cout << endl;
    
    MacBook mac;
    
    mac.OS();
    
    return 0;
}
/*
Memory()
Disk()
CPU()
MainBoard()
Computer()
power()
Ubuntu 16.04 LTS

Memory()
Disk()
CPU()
MainBoard()
Computer()
Mac OS
~Computer()
~MainBoard()
~CPU()
~Disk()
~Memory()
~Computer()
~MainBoard()
~CPU()
~Disk()
~Memory()

*/

小结

在这里插入图片描述

第44课 - 继承中的访问级别

在这里插入图片描述
在这里插入图片描述

实验-子类直接访问父类非公成员（error）

#include <iostream>
#include <string>

using namespace std;

class Parent
{
private:
    int mv;
public:
    Parent()
    {
        mv = 100;
    }
    
    int value()
    {
        return mv;
    }
};

class Child : public Parent
{
public:
    int addValue(int v)
    {
        mv = mv + v;    // ???? 如何访问父类的非公有成员  error: 'int Parent::mv' is private within this context
    }
};

int main()
{   
    return 0;
}

在这里插入图片描述

实验-子类访问父类非公成员protected

#include <iostream>
#include <string>

using namespace std;

class Parent
{
protected:
    int mv;
public:
    Parent()
    {
        mv = 100;
    }
    
    int value()
    {
        return mv;
    }
};

class Child : public Parent
{
public:
    void addValue(int v)
    {
        mv = mv + v;    //子类使用父类protected成员变量
    }
};

int main()
{   
    Parent p;
    
    cout << "p.mv = " << p.value() << endl;//p.mv = 100
    
    // p.mv = 1000;    // error
    
    Child c;
    
    cout << "c.mv = " << c.value() << endl;//c.mv = 100  子类返回父类protected成员变量
    
    c.addValue(50);
    
    cout << "c.mv = " << c.value() << endl;//c.mv = 150 
    
   // c.mv = 10000;  // error: 'int Parent::mv' is protected within this context
    
    return 0;
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

实验-复杂的例子

#include <iostream>
#include <string>
#include <sstream>

using namespace std;

class Object
{
protected:
    string mName;
    string mInfo;
public:
    Object()
    {
        mName="Object";
        mInfo="";

    }
    string GetName()
    {
        return mName;
    }
    string GetInfo()
    {
        return mInfo;
    }

};

class Point:public Object
{
private:
    int mx;
    int my;
public:
    Point(int x=0,int y=0)
    {
        mx=x;
        my=y;
        ostringstream s;
        mName="point";
        s<<"P("<<mx<<","<<my<<")";
        mInfo=s.str();
    }
    int x()
    {
        return mx;
    }
    int y()
    {
        return my;
    }
};


class Line:public Object
{
private:
    Point mp1;
    Point mp2;
public:
    Line(Point p1,Point p2)
    {
        mp1=p1;
        mp2=p2;
        ostringstream s;
        mName="Line";
        s<<"Line from "<<mp1.GetInfo()<<" to "<<mp2.GetInfo();//mp2.GetInfo()  .mInfo
        mInfo=s.str();

    }
    Point linestart()
    {
        return mp1;
    }
    Point lineend()
    {
        return mp2;
    }
};/*
*/

int main()
{

    Object o;
    Point p1(1,2);
    Point p2(3,4);
    Line L1(p1,p2);/**/
    cout<<"o.GetName():"<<o.GetName()<<endl;
    cout << "o.GetInfo():"<<o.GetInfo() << endl;

    cout << endl;

    cout << p1.GetName() << endl;
    cout << p1.GetInfo() << endl;

    cout << endl;

    cout << L1.GetName() << endl;
    cout << L1.GetInfo() << endl;
    return 0;
}
/*
o.GetName():Object
o.GetInfo():

point
P(1,2)

Line
Line from P(1,2) to P(3,4)*/

bug

s<<"Line from "<<mp1.GetInfo()<<" to "<<mp2.mInfo;//mp2.GetInfo()  .mInfo//error: 'std::string Object::mInfo' is protected|位置在父类的定义位置

小结

在这里插入图片描述

第45课 - 不同的继承方式

在这里插入图片描述
在这里插入图片描述

实验-例子

#include <iostream>
#include <string>

using namespace std;

class Parent
{
};

class Child_A : public Parent
{
};

class Child_B : protected Parent
{
};

class Child_C : private Parent
{
};

int main()
{   
    return 0;
}

在这里插入图片描述
在这里插入图片描述

实验-3种继承的对比

#include <iostream>
#include <string>

using namespace std;

class Parent
{
protected:
    int m_a;
protected:
    int m_b;
public:
    int m_c;
    
    void set(int a, int b, int c)
    {
        m_a = a;
        m_b = b;
        m_c = c;
    }
};

class Child_A : public Parent
{
public:
    void print()
    {
        cout << "m_a" << m_a <<"   "
            << "m_b" << m_b <<"   "
     << "m_c" << m_c << endl;
    }
};

class Child_B : protected Parent
{
public:
    void print()
    {
        cout << "m_a" << m_a <<"   "
                << "m_b" << m_b <<"   "
                 << "m_c" << m_c << endl;
    }
};

class Child_C : private Parent
{
public:
    void print()
    {
        cout << "m_a" << m_a << "   "
               << "m_b" << m_b << "    "
               << "m_c" << m_c << endl;
    }
};

int main()
{   
    Child_A a;
    Child_B b;
    Child_C c;
    
    a.m_c = 100;
     //b.m_c = 100;    // Child_B 保护继承自 Parent， 所以所有的 public 成员全部变成了 protected 成员， 因此外界无法访问 error: 'int Parent::m_c' is inaccessible within this context
    //c.m_c = 100;    // Child_C 私有继承自 Parent， 所以所有的成员全部变成了 private 成员， 因此外界无法访问error: 'int Parent::m_c' is inaccessible within this context
    
    a.set(1, 1, 1);
    //b.set(2, 2, 2);//error: 'Parent' is not an accessible base of 'Child_B'
    //c.set(3, 3, 3);//error: 'Parent' is not an accessible base of 'Child_C'
    
    a.print();     //m_a1   m_b1   m_c1
 // b.m_a = 100;// error: 'int Parent::m_a' is protected within this context
    b.print();    //m_a2   m_b0   m_c14639008
    c.print();    //m_a0   m_b8    m_c0
    
    return 0;
}

在这里插入图片描述

实验-多种语言分析

在这里插入代码片

gdc 45-3.d
./a.out
gmcs 45-3.cs
/45-3.exe

javac 45-3.java
java program

小结

在这里插入图片描述

第46课 - 继承中的构造与析构

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
子类对象的构造子类中
可以定义构造函数子类构造函数
一必须对继承而来的成员进行初始化
·直接通过初始化列表或者赋值的方式进行初始
调用父类构造函数进行初始化
在这里插入图片描述

实验-默认调用

#include <iostream>
#include <string>

using namespace std;

class Parent 
{
public:
    Parent()
    {
        cout << "Parent()" << endl;
    }
    Parent(string s)
    {
        cout << "Parent(string s) : " << s << endl;
    }
};

class Child : public Parent
{
public:
    Child()
    {
        cout << "Child()" << endl;
    }
    Child(string s) : Parent(s)//不能丢
    {
        cout << "Child(string s) : " << s << endl;
    }
};

int main()
{       
    Child c; //Child()  Parent() 不对
    Child cc("cc");  // Parent(string s) :cc    Child(string s) :cc
    
    return 0;
}
/*
Parent()
Child()
Parent(string s) : cc
Child(string s) : cc   */

对象创建时构造函数的调用顺序 1.
调用父类的构造函数 2.
调用成员变量的构造函数 3．调用类自身的构造函数
口诀心法：
先父母，后客人，再自己，
在这里插入图片描述
在这里插入图片描述

实验-显示调用

#include <iostream>
#include <string>

using namespace std;

class Object
{
public:
    Object(string s)
    {
        cout << "Object(string s) : " << s << endl;
    }
};

class Parent : public Object
{
public:
    Parent() : Object("Default")
    {
        cout << "Parent()" << endl;
    }
    Parent(string s) : Object(s)
    {
        cout << "Parent(string s) : " << s << endl;
    }
};

class Child : public Parent
{
    Object mO1;
    Object mO2;
public:
    Child() : mO1("Default 1"), mO2("Default 2")
    {
        cout << "Child()" << endl;
    }
    Child(string s) : Parent(s), mO1(s + " 1"), mO2(s + " 2")
    {
        cout << "Child(string s) : " << s << endl;
    }
};

int main()
{       
    Child cc("cc");
    
    return 0;
}
//先父母
//Object(string s) :cc
//Parent(string s) : cc



//再客人
//Object(string s) :cc1
//Object(string s) :cc2

//自己
//Child(string s) :cc
/*
Object(string s) : cc
Parent(string s) : cc
Object(string s) : cc 1
Object(string s) : cc 2
Child(string s) : cc
*/

在这里插入图片描述

实验-析构顺序

#include <iostream>
#include <string>

using namespace std;

class Object
{
    string ms;
public:
    Object(string s)
    {
        cout << "Object(string s) : " << s << endl;
        ms = s;
    }
    ~Object()
    {
        cout << "~Object() : " << ms << endl;
    }
};

class Parent : public Object
{
    string ms;
public:
    Parent() : Object("Default")
    {
        cout << "Parent()" << endl;
        ms = "Default";
    }
    Parent(string s) : Object(s)
    {
        cout << "Parent(string s) : " << s << endl;
        ms = s;
    }
    ~Parent()
    {
        cout << "~Parent() : " << ms << endl;
    }
};

class Child : public Parent
{
    Object mO1;
    Object mO2;
    string ms;
public:
    Child() : mO1("Default 1"), mO2("Default 2")
    {
        cout << "Child()" << endl;
        ms = "Default";
    }
    Child(string s) : Parent(s), mO1(s + " 1"), mO2(s + " 2")
    {
        cout << "Child(string s) : " << s << endl;
        ms = s;
    }
    ~Child()
    {
        cout << "~Child() " << ms << endl;
    }
};

int main()
{       
    Child cc("cc");
    
    cout << endl;
    
    return 0;
}
//Object(string s) :cc
//Parent(string s) :cc
//Object(string s) :cc 1
//Object(string s) :cc 2
//Child(string s) : cc

//~Child() cc
//~Object() :cc 2
//~Object() :cc 1
//~Parent() :cc
//~Object() :cc

小结

在这里插入图片描述

第47课 - 父子间的冲突

在这里插入图片描述

实验-子类与父类的同名变量

#include <iostream>
#include <string>

using namespace std;

class Parent
{
public:
    int mi;
};

class Child : public Parent
{
public:
    int mi;
};

int main()
{
    Child c;
    
    c.mi = 100;    // mi 究竟是子类自定义的，还是从父类继承得到的？
    
    return 0;
}

在这里插入图片描述
在这里插入图片描述

实验-区分子类与父类的同名变量

#include <iostream>
#include <string>

using namespace std;

namespace A
{
    int g_i = 0;
}

namespace B
{
    int g_i = 1;
}

class Parent
{
public:
    int mi;
    
    Parent()
    {
        cout << "Parent() : " << "&mi = " << &mi << endl;
    }
};

class Child : public Parent
{
public:
    int mi;
    
    Child()
    {
        cout << "Child() : " << "&mi = " << &mi << endl;
    }
};

int main()
{
    Child c;
    
    c.mi = 100;    
    
    c.Parent::mi = 1000;
    
    cout << "&c.mi = " << &c.mi << endl;
    cout << "c.mi = " << c.mi << endl;
    
    cout << "&c.Parent::mi = " << &c.Parent::mi << endl;
    cout << "c.Parent::mi = " << c.Parent::mi << endl;
    
    return 0;
}
/*
Parent() : &mi = 0x61fe18
Child() : &mi = 0x61fe1c
&c.mi = 0x61fe1c
c.mi = 100
&c.Parent::mi = 0x61fe18
c.Parent::mi = 1000
*/

在这里插入图片描述
在这里插入图片描述

实验-子类函数覆盖父类同名函数

#include <iostream>
#include <string>

using namespace std;

class Parent
{
public:
    int mi;
    
    void add(int v)
    {
        mi += v;
    }
    
    void add(int a, int b)
    {
        mi += (a + b);
    }
};

class Child : public Parent
{
public:
    int mi;
    
    void add(int v)
    {
        mi += v;
    }
    
    void add(int a, int b)
    {
        mi += (a + b);
    }
    
    void add(int x, int y, int z)
    {
        mi += (x + y + z);
    }
};

int main()
{
    Child c;
    
    c.mi = 100;    
    
    c.Parent::mi = 1000;
    
    cout << "c.mi = " << c.mi << endl;
    
    cout << "c.Parent::mi = " << c.Parent::mi << endl;
    
    c.add(1);//子类
    c.add(2, 3);//子类
    c.add(4, 5, 6);//子类
    //c.Parent::add(2, 3);调用父类函数
    cout << "c.mi = " << c.mi << endl;//
    
    cout << "c.Parent::mi = " << c.Parent::mi << endl;
    //c.mi = 100
//c.Parent::mi = 1000
//c.mi = 121
//c.Parent::mi = 1000
    return 0;
}

在这里插入图片描述

小结

在这里插入图片描述

第48课 - 同名覆盖引发的问题

在这里插入图片描述

实验-父类赋值给子类

用子类初始化父类
父类引用子类
父类指向子类

#include <iostream>
#include <string>

using namespace std;

class Parent
{
public:
    int mi;
    
    void add(int i)
    {
        mi += i;
    }
    
    void add(int a, int b)
    {
        mi += (a + b);
    }
};

class Child : public Parent
{
public:
    int mv;
    
    void add(int x, int y, int z)
    {
        mv += (x + y + z);
    }
};

int main()
{
    Parent p;
    Child c;
    
    p = c;//子类赋值给父类
    
    Parent p1(c);
    
    
    Parent& rp = c;//定义父类引用子类
    Parent* pp = &c;
    
    rp.mi = 100;
    rp.add(5);             // c的引用 的add预计报错  没有发生同名覆盖?
    rp.add(10, 10);        // 没有发生同名覆盖?
    
    /* 为什么编译不过? */
     //pp->mv = 1000;//error: 'class Parent' has no member named 'mv'; did you mean 'mi'?
     //pp->add(1, 10, 100);// error: no matching function for call to 'Parent::add(int, int, int)'
    
    return 0;
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

实验-函数重写

#include <iostream>
#include <string>

using namespace std;

class Parent
{
public:
    int mi;
    
    void add(int i)
    {
        mi += i;
    }
    
    void add(int a, int b)
    {
        mi += (a + b);
    }
    
    void print()
    {
        cout << "I'm Parent." << endl;
    }
};

class Child : public Parent
{
public:
    int mv;
    
    void add(int x, int y, int z)
    {
        mv += (x + y + z);
    }
    
    void print()
    {
        cout << "I'm Child." << endl;
    }
};
//void how_to_print(Child* p)//error: invalid conversion from 'Parent*' to 'Child*' [-fpermissive]
void how_to_print(Parent* p)//父类指针
{
    p->print();
}

int main()
{
    Parent p;
    Child c;
    
    how_to_print(&p);    // Expected to print: I'm Parent.
    how_to_print(&c);    // Expected to print: I'm Child.
    
    return 0;
}
//I'm Parent.
//I'm Parent.

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

小结

在这里插入图片描述

cyz24
关注
  • 16
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++ Primer Plus- 类与对象-note2
sunqian_119的博客
04-02 340
读书笔记《C++ Primer Plus》-类与对象部分
Effective c++ 读书笔记
guotianqing的博客
12-16 227
说明 学习语言本身是一回事，学习如何使用这种语言进行设计和高效编程是另一回事。 这本书就是在有了一定的基础知识后，在实际项目开发和后续学习中的必读经典。它基于编程实际，以条款的形式描述了需要避开的坑和需要遵守的高效原则。 读过《c缺陷与陷阱》的朋友，可能在读这本书时能找到当时相同的感觉。 一口气读完了本书，余音绕梁，意犹未尽。重新翻阅本书，并作此记录，以供后续复习之用。 主要内容 习惯c+...
C++ Primer Plus-代码重用-note3
sunqian_119的博客
08-18 972
读书笔记《C++ Primer Plus 》代码重用
《C++ Templates》笔记 PartI:The Basics
MYTCHITOS的博客
07-25 819
C++ Templates PartI:The Basics 文章目录C++ Templates PartI:The BasicsChapter 1 Function Templates1.1 A First Look at Functiion Templates1.1.1 Defining the Template1.1.2 Using the Template1.1.3 Two-Phase...
C++ Primer 笔记
Jasper6688的博客
06-15 2627
第二章 开始学习c++ 1 第三章 数据处理 1 3.1简单变量 1 3.2 const限定符 2 3.3浮点数 2 3.4 c++算术操作符 2 第四章  复合类型 2 4.1数组（array） 2 4.2 字符串 3 4.3 string类简介 3 4.4 结构(struct)简介 4 4.5 共用体（union） 5 4.6枚举类型(enum) 5 4.7指针
《深度探索C++对象模型》读书笔记
Jin的专栏
09-01 977
1.在通常情况下C++实现了封装性，但并没有曾加成本，类中声明了成员变量和成员函数，在定义类对象的时候，类的开销就是成员变量的开销，对象中不会出现成员函数的实例。每一个non-inline member function只会诞生一个函数实例。至于每一个“拥有零个或一个定义”的inline function则会在其每一个使用者（模版）身上产生一个函数实例。类一定程度上支持了封装性质，而且并没有影响空
计算机读书笔记
最佳损友1020的博客
11-11 1619
应该在表达式中使用强制类型转换，使操作数均为有符号数或者无符号数，这样就不必由编译器来选择结果的类型。当表达式中存在有符号数和无符号数类型时，所有的操作都自动转换为无符号类型。可见无符号数的运算优先级高于有符号数。无符号数转换为有符号数时，对于小的数将保持原值，对于大的数将转换为负数，相当于原值减去2的n次方。有符号数转换为无符号数时，负数转换为大的正数，相当于在原值上加上2的n次方，而正数保持不变。无符号整数和有符号整数之间进行强制类型转换时，位模式不改变。相邻的字符串常量将会自动合并成一个字符串。
Go语言基础重点整理（配套视频课与pdf原文笔记）-1
文杰的博客
11-22 2250
一、尚硅谷Go语言教程 PDF阅读： http://xwjpics.gumptlu.work/%E5%B0%9A%E7%A1%85%E8%B0%B7_%E9%9F%A9%E9%A1%BA%E5%B9%B3_Go%E8%AF%AD%E8%A8%80%E6%A0%B8%E5%BF%83%E7%BC%96%E7%A8%8B.pdf 二、go基础重点总结 1. 环境变量配置 2. Golang 执行流程分析 如果是对源码编译后，再执行，Go 的执行流程如下图 如果我们是对源码直接执行go run 源码，
《Effective C++》 笔记
qq_40586164的博客
10-11 774
导读 被声明为explicit的构造函数通常比其non-explici兄弟更受欢迎，因为它们禁止编译器执行非预期（往往也不被期望）的类型转换。**除非我有一个好理由允许构造函数被用于隐式类型转换，否则我会把它声明为explicit。**我鼓励你遵循相同的政策。 copy构造和copy赋值的区别： 如果一个新对象被定义（例如以上语句中的w3），一定会有个构造函数被调用，不可能调用赋值操作。如果没有新对象被定义（例如前述的"w1=w2"语句），就不会有构造函数被调用，那么当然就是赋值操作被调用。 函数Pass
深入解析C++中类的多重继承
12-31
C++类的多继承 在前面的例子中，派生类都只有一个基类，称为单继承。除此之外，C++也支持多继承，即一个派生类可以有两个或多个基类。 多继承容易让代码逻辑复杂、思路混乱，一直备受争议，中小型项目中较少使用，...
派生类的构造与析构_派生类的构造与析构_
10-03
在实际编程中，派生类的构造与析构机制对于实现多态性和继承关系至关重要。例如，在游戏开发中，可以有一个基本的“游戏对象”类，然后派生出“角色”、“敌人”等具体类，每个类都有其特定的构造和析构逻辑。通过...
C++构造函数和析构函数的使用与讲解
08-26
"C++构造函数和析构函数的使用与讲解" C++语言中，构造函数和析构函数是两个非常重要的概念，它们都是类成员函数，分别用于对象的创建和销毁。本文将详细讲解构造函数和析构函数的使用和实现。 1. 构造函数 构造...
深入解析C++编程中基类与基类的继承的相关知识
09-02
在深入解析C++基类与继承的过程中，我们需要理解以下几个关键概念： 1. **单一继承与多重继承**： - **单一继承**：一个派生类从一个基类继承。在这种情况下，派生类只有一个直接基类，但可以间接继承更多的基类。...
cpp代码-继承和组合混搭情况下的类构造和析构
07-16
这个项目“cpp代码-继承和组合混搭情况下的类构造和析构”着重探讨了这两种机制在类构造和析构过程中的交互作用。以下是关于这个主题的详细解释。 **继承（Inheritance）**： 继承允许一个类（子类或派生类）从另一...
函数模板与类模板
程序员_小兵
07-12 1554
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
Linux C | 管道open打开方式
最新发布
I_feige的博客
07-12 321
1.
C++ 多态
wxk2227814847的博客
07-10 790
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
Reversing Numbers C++
FGGFFoj的博客
07-11 377
在默认情况下，C++的输入输出流（比如 cin, cout）与C标准库的输入输出流是同步的，这意味着在使用C++的输入输出流时，可能会因为需要与C标准库的同步而导致性能略有损失。在 C++ 中，默认情况下，cin 和 cout 是绑定在一起的，意味着在输入时，输出可能需要等待输入完成才会进行，这样可能会造成一些性能上的损失，特别是在需要频繁输入输出的场景下。需要注意的是，在取消同步后，应确保不要混合使用C++的输入输出和C标准库的输入输出，因为这可能会导致未定义的行为。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值