慕课网-C++远征之继承篇（上）-学习笔记

最新推荐文章于 2024-06-20 07:39:02 发布
最新推荐文章于 2024-06-20 07:39:02 发布
阅读量186 收藏
点赞数
文章标签： c/c++
原文链接：https://yq.aliyun.com/articles/631023
版权

C++远征之继承篇

开篇介绍

起航->离港->封装->继承

  • 为什么要用继承？
  • 为什么要有继承？
  • 基类 <----> 派生类
  • 公有继承，保护继承，私有继承
  • IS-a & Has a
  • 多重继承 & 多继承 & 虚继承

为什么继承？

儿子继承父亲财产

  • 生活中继承 不等于 c++中的继承

为什么要有继承？

例子：

人类：

class Person
{
public:
    void eat();
    string m_strName;
    int m_iAge;
}

工人(人类的一种)：

class Worker
{
public:
    void eat();//
    void work();
    string m_strName;//
    int m_iAge;//
    int m_iSalary;

}

代码重用。超集子集

class Worker: public Person
{
public:
    void work();
    int m_iSalary;

}
  • 此时工人类是人类的派生类。人类是工人类的基类。
  • 工人类（子类） & 人类（父类）
基类-派生 & 父类-子类

内存中的对象：

内存中的父类子类
代码演示

要求：

  • 实例化时先实例化父类，再实例化子类。而析构函数正好相反。
  • 子类已经同时具有父类的数据成员和成员函数
要求

Person.h:

#include <string>
using namespace std;

class  Person
{
public:
     Person();
    ~ Person();
    void eat();
    string m_strName;
        int m_iAge;
private:

};

Person.cpp:

#include "Person.h"
#include <iostream>

using namespace std;

Person::Person()
{
    cout << "Person()" << endl;

}

Person::~Person()
{
    cout << "~Person()" << endl;

}

void Person::eat() {
    cout << "eat()" << endl;
}

worker.h:

#include "Person.h"

class Worker:public Person
{
public:
    Worker();
    ~Worker();
    void work();
    int m_iSalary;
};

worker.cpp:

#include "Worker.h"
#include <iostream>

using namespace std;

Worker::Worker()
{
    cout << "Worker()" << endl;

}
Worker::~Worker()
{
    cout << "~Worker()" << endl;

}

void Worker::work()
{
    cout << "Work" << endl;
}

main.cpp:

#include "Worker.h"
#include <stdlib.h>
#include <iostream>

using namespace std;

int main(void)
{
    Worker *p = new Worker();
    p->m_strName = "Jim";
    p->m_iAge = 10;
    p->eat();
    p->m_iSalary = 1000;
    p->work();
    delete p;
    p = NULL;
    system("pause");
    return 0;
}
运行结果

继承方式

  • 公有继承: class A:public B
  • 保护继承: class A:protected B
  • 私有继承: class A:private B
公有继承
class  Person
{
public:
    void eat();
    string m_strName;
        int m_iAge;
};

class Worker:public Person
{
public:
    void eat();//
    void work();
    int m_iAge;//
    string m_strName;//
    int m_iSalary;
};

private和protected在继承时的区别：

  • 子类通过protect继承了父类的时候，子类可以通过自己来访问父类的数据成员。
  • 子类通过private继承了父类的时候，子类不能通过自己来访问父类的数据成员，父类的数据成员只有通过自己才能访问。
class  Person
{
public:
    void eat();
protected:
    int m_iAge;
private:
    string m_strName;
    
};

int main()
{
    Person person;
    person.eat(); //正确
    person.m_iAge = 20; //禁止访问
    person.m_strName = "jim"; //禁止访问
    return 0;
}

void Person::eat()
{
    m_strName = "jim";
    m_iAge = 10;
}

实现成员函数时。我们的私有保护数据成员也是可以正常访问的。
但当protected 遇到 继承

class  Person
{
public:
    void eat();
protected:
    int m_iAge;
    string m_strName;
    
};

class Worker:public Person
{
public:
    void eat();//
    void work(){m_iAge = 20;};//继承下来之后可以通过work访问到age
protected:
    int m_iAge;//
    string m_strName;//
    int m_iSalary;
};

public 的继承到public。 protected的继承到protected

class  Person
{
public:
    void eat();
private:
    int m_iAge;
    string m_strName;
    
};

class Worker:public Person
{
public:
    void eat();//
    void work(){m_iAge = 20;};//继承下来之后可以通过work访问到age
private:
    int m_iSalary;
};

public的继承到public。父类中的private被继承到了不可见位置。而不是private。
所以，此时通过work操作m_iage会出错。

公有继承
公有继承代码示例

要求：

要求

person.h:

#include <string>
using namespace std;

class  Person
{
public:
     Person();
    ~ Person();
    void eat();
protected:
    string m_strName;
private:
    int m_iAge;


};

#include "Person.h"
#include <iostream>

using namespace std;

Person::Person()
{
    cout << "Person()" << endl;

}

Person::~Person()
{
    cout << "~Person()" << endl;

}

void Person::eat() {
    m_strName = "Jim";
        m_iAge = 20;
    cout << "eat()" << endl;
}

main.cpp

//#include "Worker.h"
#include <stdlib.h>
#include <iostream>
#include "Person.h"

using namespace std;

int main(void)
{/*
    Worker worker;
    worker.m_strName = "Jim";
    worker.m_iAge = 10;
    worker.eat();
    worker.m_iSalary = 1000;
    worker.work();*/

    Person person;
    //person.eat();
    //person.m_strName = "merry"; //无法访问 protected 成员
    //person.m_iAge = 20; //无法访问 private 成员
    system("pause");
    return 0;
}
  • 类本身的public成员函数，函数内部可以访问到类自身的保护以及私有成员。
  • 而类内受保护的私有成员，保护成员。无法在类外直接被访问。

公有继承之后父类的私有数据成员被子类继承却无法正常使用。

子类中的protected成员父类也可以正常访问。被放在了父类protected。

class  Person
{
public:
     Person();
    ~ Person();
    void eat();
protected:
    string m_strName;
    int m_iAge;
};

void Worker::work()
{
    m_iAge = 10;
    m_strName = "Jim";
    cout << "Work" << endl;
}

int main(void)
{
    Worker worker;
    worker.work();

    system("pause");
    return 0;
}

结果：正常运行。

  • 父类的private数据成员父类是否可以正常访问：不可以

将上面代码中person下的protected改为private

则会报错：

Person::m_iAge”: 无法访问 private 成员(在“Person”类中声明)
c++保护继承，私有继承
  • 公有继承: class A:public B
  • 保护继承: class A:protected B
  • 私有继承: class A:private B
公有继承
保护继承
私有继承

例子：

class Line{
public:
    Line(int x1,int y1, int x2,int y2);
private:
    Coordinate m_coorA;//只能访问到公有数据成员和公有成员函数
    Coordinate m_coorB;
}
  • 线段和坐标的关系：has -a（包含）
  • 私有继承（包含） 因为子类对象包含父类：只能访问父类当中公有数据成员和成员函数。
保护与私有继承代码演示

要求：

要求

protected继承：

  • public成员可以一直protected继承下去，被继承后属于protected，不可以被对象直接访问；
  • protected成员可以一直protected继承下去，被继承后属于protected，不可以被对象直接访问；
  • private成员不能被protected继承。

公有继承代码：

person:

#include <string>
using namespace std;

class  Person
{
public:
     Person();
     void play();

protected:
    string m_strName;
};

#include <iostream>
#include "Person.h"
using namespace std;

Person::Person()
{
    m_strName = "merry";
}

void Person::play() {
    cout << "person - play" << endl;
    cout << m_strName << endl;
}

Soldier:

#include "Person.h"

class  Soldier:public Person
{
public:
     Soldier();
     void work();

private:
    int m_iAge;
};

#include "Soldier.h"
#include <iostream>
using namespace std;

Soldier::Soldier()
{
}

void Soldier::work()
{
    m_strName = "JIm";
    m_iAge = 20;
    cout << m_strName << endl;
    cout << m_iAge << endl;
    cout << "soldier - work" << endl;
}

Infantry:

#include "Soldier.h"

class Infantry:public Soldier {
public:
    void attack();
};

#include <iostream>
#include "Infantry.h"

using namespace std;

void Infantry::attack() {
    cout << "Infantry --attack" << endl;

}

main.cpp:

#include "Soldier.h"
#include <stdlib.h>
#include <iostream>

int main()
{
    Soldier soldier;
    soldier.work();//work会间接的访问到基类person中的m_strname
    //进行了公有继承，父类的protected数据成员会被继承到子类的protected下面
    //父类的public也会继承到子类的public下面
    soldier.play();//调用父类的成员函数
    system("pause");
    return 0;
}

运行结果：

运行结果

改用protected：

  • 如果slodier保护继承了person，那么person下的public和protected数据成员成员函数都会被继承到solider的protect中
  • 此时通过一个类（Infantry）来公共继承soldier则可以在它自身的成员函数attack中访问到person的数据成员以及成员函数。

完整代码：

#include <string>
using namespace std;

class  Person
{
public:
     Person();
     void play();

protected:
    string m_strName;
};

#include <iostream>
#include "Person.h"
using namespace std;

Person::Person()
{
    m_strName = "merry";
}

void Person::play() {
    cout << "person - play" << endl;
    cout << m_strName << endl;
}


#include "Person.h"

class  Soldier:protected Person
{
public:
     Soldier();
     void work();
//通过子类的对象只能访问子类自己的public下面的成员。
//不能访问到基类的public成员了，因为基类的被放到protected下了

protected:
    int m_iAge;
};


#include "Soldier.h"
#include <iostream>
using namespace std;

Soldier::Soldier()
{
}

void Soldier::work()
{
    m_strName = "JIm";
    m_iAge = 20;
    cout << m_strName << endl;
    cout << m_iAge << endl;
    cout << "soldier - work" << endl;
}


#include "Soldier.h"

class Infantry:public Soldier {
public:
    void attack();
};


#include <iostream>
#include "Infantry.h"

using namespace std;

void Infantry::attack() {
    m_strName = "Jim";
    cout << m_strName<< endl;
    cout << "Infantry --attack" << endl;

}


//#include "Soldier.h"
#include <stdlib.h>
#include <iostream>
#include "Infantry.h"
int main()
{
    //Soldier soldier;
    //soldier.work();//work会间接的访问到基类person中的m_strname
    //进行了公有继承，父类的protected数据成员会被继承到子类的protected下面
    //父类的public也会继承到子类的public下面
    //soldier.play();//调用父类的成员函数
    //“Person::play”不可访问，因为“Soldier”使用“protected”从“Person”继承
    
    Infantry soldier;
    soldier.attack();

    system("pause");
    return 0;

}

private继承方式：

#include <string>
using namespace std;

class  Person
{
public:
     Person();
     void play();

protected:
    string m_strName;
};


#include <iostream>
#include "Person.h"
using namespace std;

Person::Person()
{
    m_strName = "merry";
}

void Person::play() {
    cout << "person - play" << endl;
    cout << m_strName << endl;
}


#include "Person.h"

class  Soldier:private Person
{
public:
     Soldier();
     void work();
//通过子类的对象只能访问子类自己的public下面的成员。
//不能访问到基类的public成员了，因为基类的被放到protected下了

protected:
    int m_iAge;
private:
    //private继承，此时person的protect，public被继承到了子类的private
    //此时soldier可以访问到。但是继承自它的infantry就访问不到了
};


#include "Soldier.h"
#include <iostream>
using namespace std;

Soldier::Soldier()
{
}

void Soldier::work()
{
    m_strName = "JIm";
    m_iAge = 20;
    cout << m_strName << endl;
    cout << m_iAge << endl;
    cout << "soldier - work" << endl;
}


#include "Soldier.h"

class Infantry:public Soldier {
public:
    void attack();
};


#include <iostream>
#include "Infantry.h"

using namespace std;

void Infantry::attack() {
    //“Person::m_strName”: 无法访问 无法访问的 成员(在“Person”类中声明)
    //m_strName = "Jim";
    //cout << m_strName<< endl;
    cout << "Infantry --attack" << endl;

}


//#include "Soldier.h"
#include <stdlib.h>
#include <iostream>
#include "Infantry.h"
int main()
{
    //Soldier soldier;
    //soldier.work();//work会间接的访问到基类person中的m_strname
    //进行了公有继承，父类的protected数据成员会被继承到子类的protected下面
    //父类的public也会继承到子类的public下面
    //soldier.play();//调用父类的成员函数
    //“Person::play”不可访问，因为“Soldier”使用“protected”从“Person”继承
    
    Infantry soldier;
    soldier.attack();

    system("pause");
    return 0;

}
  • B类从A类派生，那么B类中含有A类的所有数据成员（私有的也被继承过来了，只不过不能用）
  • B类从A类公共派生，那么可以在B类中直接使用A的公共及保护限定符的数据成员。不能使用私有成员
  • B类从A类公共派生，那么A类的私有成员函数不能被B类继承并使用。
  • B类从A类私有派生，那么A类的公共成员函数成为B类的私有成员函数。
巩固练习

定义两个类，人类中含有数据成员姓名（m_strName）及成员函数eat()
士兵类从人类派生，含有数据成员编号（m_strCode)及成员函数attack()
在main函数通过对数据的访问，体会公有继承的语法特点。

#include <iostream>
#include <stdlib.h>
#include <string>
using namespace std;

/**
 * 定义人的类: Person
 * 数据成员姓名: m_strName
 * 成员函数: eat()
 */
class Person
{
public:
    string m_strName;
    void eat()
    {
        cout << "eat" << endl;
    }
};

/**
 * 定义士兵类: Soldier
 * 士兵类公有继承人类: public
 * 数据成员编号: m_strCode
 * 成员函数: attack()
 */
class Soldier:public Person
{
public:
    string m_strCode;
    void attack()
    {
        cout << "fire!!!" << endl;
    }
};

int main(void)
{
    // 创建Soldier对象
    Soldier soldier;
    // 给对象属性赋值
    soldier.m_strName = "Jim";
    soldier.m_strCode = "592";
    // 打印对象属性值
    cout << soldier.m_strName << endl;
    cout << soldier.m_strCode << endl;
    // 调用对象方法
    soldier.attack();
    soldier.eat();

    return 0;
}

c++隐藏

覆盖 <-> 隐藏 很容易混淆

什么是隐藏？
隐藏
  • 父子两代，都有同名函数。子类会将父类的函数隐藏。
  • 表现在。实例化b对象时，只能直接访问到b中的abc方法。
  • 但是实际上父类的abc方法只是隐藏了起来，通过特殊手段还可以访问到。
  • 同名数据成员和成员函数都具有隐藏性质

父子关系 & 成员同名 & 隐藏

代码：

class Person
{
public:
    void play();
protected:
    string m_strName;
};

class Soldier:public Person
{
public:
    void play();
    void work();
protected:
    int m_iCode;
}

调用示例代码：

int main()
{
    Soldier soldier;
    soldier.play();//soldier自己的play
    soldier.Person::play();//可以调用到父类人的play

    return 0;

}

数据成员同名：

数据成员同名 
void Soldier::work()
{
    code = 1234;
    Person::code = "5678";//访问到的是父类的数据成员
}

可以通过命名方法避免重名

隐藏编码实例
要求
  • ""在程序目录下找
  • <>在程序默认库查找- 右键打开文档可以打开
  • #include<string>时，需要配套使用using namespace std;才可正常使用string,否则会出错,也就是string类型应该是在std命名空间。
  • 继承只有一个冒号。而类的方法。两个。
  • 使用string类型必须包含<string>
  • 声明类的最后要加分号.

程序代码：

#include <string>
using namespace std;

class Person
{
public:
    Person();
    void play();
protected:
    string m_strName;
};

//
#include "Person.h"
#include <iostream>
using namespace std;
#include "stdafx.h"
Person::Person()
{
    m_strName = "merry";

}

void Person::play()
{
    cout << "person - play()" << endl;
    cout << m_strName << endl;
}

//
#include "Person.h"

class  Soldier:public Person
{
public:
     Soldier();
     void play();
     void work();

protected:


};


//
#include "Soldier.h"
#include <iostream>
using namespace std;
#include "stdafx.h"

Soldier::Soldier()
{

}
void Soldier::play() {
    cout << "soldier - play()" << endl;

}

void Soldier::work() {
    cout << "soldier - work()" << endl;
}

//main.cpp:
#include <iostream>
#include <stdlib.h>
#include "Soldier.h"
#include "stdafx.h"
int main()
{
    Soldier soldier;
    soldier.play();
    soldier.work();
    system("pause");
    return 0;
}

运行结果：

play和work都调用的是soldier的。

隐藏编码二

如果想要打印Person的。则需要soldier.Person::play();

可以调用到person下的play。

当前不仅同名而且参数相同。如果参数不同，还会隐藏？

是的即使参数不同，也不会形成重载，只是隐藏。

int main()
{
    Soldier soldier;
    soldier.play(7);
    soldier.work();
    soldier.play();//虽然与父类的参数要求一致。但当前父类方法被隐藏无法调用到
    //soldier.Person::play();
    system("pause");
    return 0;
}

void Person::play()
{
    cout << "person - play()" << endl;
    cout << m_strName << endl;
}

void Soldier::play(int x) {
    cout << "soldier - play()" << endl;

}

报错：

error C2660: “Soldier::play”: 函数不接受 0 个参数
  • 说明即使参数不同。父类和子类的同名函数也不形成重载。而是隐藏。
数据成员重名
#include <string>
using namespace std;

class Person
{
public:
    Person();
    void play();
protected:
    string m_strName;
};

//

#include "Person.h"
#include <iostream>
using namespace std;
#include "stdafx.h"
Person::Person()
{
    m_strName = "merry";

}

void Person::play()
{
    cout << "person - play()" << endl;
    cout << m_strName << endl;
}

//
//
#include "Person.h"

class  Soldier:public Person
{
public:
     Soldier();
     void play(int x);
     void work();

protected:
    string m_strName;

};

//
//
#include "Soldier.h"
#include <iostream>
using namespace std;
#include "stdafx.h"

Soldier::Soldier()
{

}
void Soldier::play(int x) {
    cout << m_strName << endl;//打印出的是soldier下的
    cout << Person::m_strName << endl;//打印父类的
    cout << "soldier - play()" << endl;

}

void Soldier::work() {
    m_strName = "solider"; //只能赋值给soldier下的m_strname
    Person::m_strName = "Person";
    cout << "soldier - work()" << endl;
}

//
//
#include <iostream>
#include <stdlib.h>
#include "Soldier.h"
#include "stdafx.h"
int main()
{
    Soldier soldier;
    soldier.work();
    soldier.play(7);
    soldier.Person::play();
    system("pause");
    return 0;
}

isA

隐形眼镜也是眼镜 - Is-a

  • 眼镜： 基类
  • 隐形眼镜： 派生类
工人士兵都是人的对象 
int main()
{
    Soldier s1;
    Person p1 = s1;//用s1区实例化p1.这样做在语法上是正确的。士兵也是人。

    Person *p2 = &s1; //正确

    s1 = p1;//人是士兵，错误。
    Soldier *s2 = &p1;//错误
    return 0;
}

将基类的指针或者引用。作为函数参数来使他可以接受子类的对象也可以传入基类的对象。

基类作为参数
  • fun1和fun2都可以传入Person 或 Soldier的对象。

  • fun1要求传入的参数是指针，所以传入 &p1对象p1的地址。

  • 而fun2要求传入的是对象p。所以可以直接传入

  • 基类指针指向派生类对象： Person　*p = &soldier;

  • 派生类对象初始化基类对象： Person p1 = soldier;

存储结构：

子类父类内存
  • 子类中有父类继承下来的数据成员.
  • 当通过子类初始化父类时。会将继承下来的数据成员复制。其他子类自有的截断。
  • 父类指针指向子类对象。父类也只能访问到自己遗传下去的。无法访问到子类自有的。
Is-a 编码
要求

main.cpp:

#include <iostream>
#include <stdlib.h>
#include "Soldier.h"
#include "stdafx.h"
int main()
{
    //Soldier soldier;
    //Person p = soldier;//使p中那么改变

    //Person p;
    //p = soldier;

    //无论是soldier初始化p。还是直接赋值。都使得p的name值为子类的name。
    //Person *p = &soldier;
    //p->play();
    //无论是对象赋值，还是指针指向。都使得p的name值为子类的name。
    //p->work();// error C2039: “work”: 不是“Person”的成员
    
    //如果通过父类的指针指向子类的对象。那么销毁时，执行子类还是父类的析构函数
    Person *p = new Soldier;

    p->play();

    delete p;
    p = NULL;
    //只执行了父类的析构函数。子类的没有执行。要用到虚的析构函数
    //当存在继承关系。父类的指针指向堆中的子类的对象。并且还想使用父类的指针把子类的也释放掉
    
    system("pause");
    return 0;
}

//实例化步骤：1. person() 2. soldier 3. person-play 4. james

person.h:

#include <string>
using namespace std;

class Person
{
public:
    Person(string name = "jim");
    virtual ~Person();// 虚析构函数，可继承。soldier内的也会是虚的。
    void play();
protected:
    string m_strName;
};

Person.cpp:

#include "Person.h"
#include <iostream>
#include <string>
using namespace std;
#include "stdafx.h"
Person::Person(string name)
{
    m_strName = name;
    cout << "person()" << endl;

}
Person::~Person()
{
    cout << "~person()" << endl;
}

void Person::play()
{
    cout << "person - play()" << endl;
    cout << m_strName << endl;
}

soldier.h:

#include "Person.h"
#include <string>
using namespace std;

class  Soldier:public Person
{
public:
     Soldier(string name = "james",int age =20);
     virtual ~Soldier();
     void work();

protected:
    string m_iAge;

};

slodier.cpp:

#include "Soldier.h"
#include <iostream>
using namespace std;
#include "stdafx.h"

Soldier::Soldier(string name,int age)
{
    m_strName = name;
    m_iAge  = age;
    cout << "Soldier()" << endl;
 }

Soldier::~Soldier() {
    cout << "~Soldier()" << endl;
}
void Soldier::work() {
    cout << m_strName << endl;
    cout << m_iAge << endl;
    cout << "Soldier -- work" << endl;
}

运行结果：

运行结果
  • 虚析构函数是为了解决基类的指针指向堆中的派生类对象，并用基类的指针删除派生类对象。
  • 如果析构函数不是虚函数，则编译器实行静态绑定，在删除基类指针时，只调用基类的析构函数而不调用派生类的析构函数。

is-A 编码二

要求

情况1：

#include <iostream>
#include <stdlib.h>
#include "Soldier.h"
#include "stdafx.h"

void test1(Person p)
{
    p.play();

}
void test2(Person &p)
{
    p.play();

}
void test3(Person *p)
{
    p->play();

}

int main()
{
    Person p;
    Soldier s;
    test1(p);
    test1(s);

    system("pause");
    return 0;
}

运行结果：

两次析构函数

两次析构函数是在两个test1执行完之后自动执行的。因为此时传入一个临时变量p。用完就要销毁掉。

    test2(p);
    test2(s);

运行结果：

test2:引用中间没有中间变量的销毁

因为传入的是引用。所以里面调用的仍是传入的对象本身。没有中间变量。

    test3(&p);
    test3(&s);

与test2实验结果完全一致。p分别调用基类和派生类的play

结论：test2 & test3 不会产生临时变量，效率更高。

巩固练习

定义两个类，基类是人类，定义数据成员姓名（name），及成员函数void attack()。
士兵类从人类派生，定义与人类同名的数据成员姓名（name）和成员函数void attack()。
通过对同名数据成员及成员函数的访问理解成员隐藏的概念及访问数据的方法。

#include <iostream>
#include <stdlib.h>
#include <string>
using namespace std;

/**
 * 定义人类: Person
 * 数据成员: m_strName
 * 成员函数: attack()
 */
class Person
{
public:
    string m_strName;
    void attack()
    {
        cout << "attack" << endl;
    }
};

/**
 * 定义士兵类: Soldier
 * 士兵类公有继承人类
 * 数据成员: m_strName
 * 成员函数: attack()
 */
class Soldier:public Person
{
public:
    string m_strName;
    void attack()
    {
        cout << "fire!!!" << endl;
    }
};

int main(void)
{
    // 实例士兵对象
    Soldier soldier;
    // 向士兵属性赋值"tomato"
    soldier.m_strName = "tomato";
    // 通过士兵对象向人类属性赋值"Jim"
    soldier.Person::m_strName = "Jim";
    // 打印士兵对象的属性值
    cout << soldier.m_strName << endl;
    // 通过士兵对象打印人类属性值
    cout << soldier.Person::m_strName << endl;
    // 调用士兵对象方法
    soldier.attack();
    // 通过士兵对象调用人类方法
    soldier.Person::attack();

    return 0;
}
weixin_33962923
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++远征之继承篇学习笔记之一
07-21
本能文章是关于C++编程中关于继承的内容。
C++非常实用-学习-总结-笔记-.pdf
11-16
C++非常实用-学习-总结-笔记-.pdf
慕课网：C++ & 数据结构
weixin_33795833的博客
07-18 314
课程链接：james_yuan的课程 这部分太枯燥了，如果教材难度稍大，根本就学不下去，所以就先看看通俗的视频吧。 课程目录 1.C++远征之起航篇 - C++亮点尽在其中 2.C++远征之离港篇 - C++扫清通往面向对象的最后一道障碍 3.C++远征之封装篇（上） - 封装--面向对象的基石。 4.C++远征之封装篇（下）- 封装--面向对象三大特征之一 5.C+...
c++慕课网3
白崽啦啦啦的博客
10-18 337
深拷贝浅拷贝 第一问： Array.hclass Array { public: Array(); Array(const Array&arr); ~Array(); void setCount(int count); int getCount(); private: int m_iCount;}; Array.cpp#include<iostre
C++笔记整理（一）基础知识点--慕课网
北川大大的博客
04-19 348
听慕课网所讲：1、C++之父：比亚尼2、C++是面向过程+对象3、C++两种初始化方法    a 复制初始化： int x=1024；    b 直接初始化： int x(1024);4 进制：oct 8进制dec 10进制hex 16进制5、基本数据的引用    int a=3；    int &amp;b=a；    b=10；6、函数参数默认值    如果有默认值的参数必须在最右端    无...
C++学习笔记（一） 补充篇 基础语法 — 参考慕课网 值得推荐！
DavidHan008
08-25 4343
2016年8月23日 前段时间真的是恍然大悟，书看错了，我看的 C++ prime plus看的真心的难受，也不知道这本书到底在写什么。 2016年8月28日 一晃又过了4-5天，真快啊，发现那本visual C++从入门到精通真本书简直就是垃圾中的极品，什么叫14小时语音视频讲解，我勒个去，就是照着书上一个字都不拉的读，关键还有读错字，学习那么这么学啊，没有作业技能得不到练习！关键还浪费了我
慕课网-c++教程起航篇-学习笔记
weixin_34177064的博客
08-22 242
c++教程起航篇 C语言是C++的子集。 c语言是面向过程的语言，而C++是面向过程的语言又是面向对象的语言。 C语言的运行效率比c++更好。 IDE环境搭建 vs2015 新建项目 新建文件 如何设置字体字号（工具选项） #include<iostream> using name...
C++非常实用-学习-总结-笔记.pdf
11-16
C++非常实用-学习-总结-笔记.pdf
2024届求职-C++后端-学习笔记-操作系统、计算机网络、C++语言+算法
03-12
2024届求职-C++后端-学习笔记-操作系统、计算机网络、C++语言+算法 2024届求职-C++后端-学习笔记-操作系统、计算机网络、C++语言+算法 2024届求职-C++后端-学习笔记-操作系统、计算机网络、C++语言+算法 2024届求职-...
C++学习笔记之继承
01-08
继承：是类之间定义的一种重要关系。 按照生活中的思考方式的话，就是继承老一辈的手艺并且在新的一辈中得到创新与传承，这里只不过是用在了类的关系上面，即老类与新类，父类与子类 继承举例： //写一个继承 //父类...
c++小白慕课网程序6
白崽啦啦啦的博客
10-29 299
c++模板篇 使用友元函数，使得传入进来的对象去访问他的私有数据成员和成员函数 time.h#pragma once #ifndef TIME_H #define TIME_H#include"match.h"//match是从哪里来的 #include<iostream> using namespace std;class Time { friend void Match:: prin
c++小白慕课网教程的一些程序
白崽啦啦啦的博客
10-17 625
#include #include #include using namespace std; int main(void) { string name; cout  "please input your name:"  endl; getline(cin, name); if (name.empty()) { cout  "input is null.."; system
C++小白慕课网的一些程序2
白崽啦啦啦的博客
10-17 351
Teacher.h#include<iostream> #include<string> using namespace std; class Teacher { public: Teacher(string name="Jim",int age=1,int m=100);//自定义有参数默认构造函数 void setName(string name); string get
慕课网-C++远征之继承篇（下）-学习笔记
weixin_33919950的博客
08-29 325
C++远征之继承篇（下） 多继承与多重继承 多重继承： 多重继承 多重继承-Is-a关系 class Person { }; class Soldier: public Person { }; class Infantryman: public Soldier { }; 多继...
2016.12.15
Night__Day的博客
12-19 315
张凌枫〈2016.12.15〉〔连续第28天总结〕A.今日任务 1.多学习一个 2.复习英语高数B.具体任务 1.定义两个类，基类是人类，定义数据成员姓名（name），及成员函数void attack()。 士兵类从人类派生，定义与人类同名的数据成员姓名（name）和成员函数void attack() 2.观望了一下英语，做了些听力，应该是过不了了 3.开了两把以撒，充分证明了
OpenGL3.3_C++_Windows(13)
最新发布
sengyongan的博客
06-20 590
dataNULL，
0x0000007b应用程序错误解决
kupePoem的专栏
06-18 530
一般用Visual C++开发的Windows应用程序需要这个运行时库的支持才能在没有安装Visual C++的计算机上正常运行，也可以在开发软件时选择”在静态库中使用 MFC“，从而将调用的库函数的代码嵌入应用程序，避免对运行时库的依赖。- Visual C++ Redistributable for Visual Studio 2013 (v12): 分别有x86和x64版本，文件名通常是`vcredist_x86.exe`和`vcredist_x64.exe`。二 vcredist。
{}初始化
qq_42863961的博客
06-17 122
不能确定是函数定义还是对象定义。可以通过 int 定义。
OpenGL3.3_C++_Windows(12)
sengyongan的博客
06-17 657
ref。
c++ 默认继承_C++学习刷题13--继承的实现、继承的方式
05-27
C++中默认的继承方式是私有继承。也就是说，如果没有显式地指定继承方式，派生类会默认继承基类的所有成员，但这些成员都会变成私有成员，不能被外部访问。 C++中有三种继承方式，它们分别是： 1.公有继承（public...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值