C++远征之继承篇（笔记）

最新推荐文章于 2022-04-13 09:30:23 发布
最新推荐文章于 2022-04-13 09:30:23 发布
阅读量465 收藏
点赞数
分类专栏： C++学习 文章标签： C++基础 继承
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cj_who_knows/article/details/79117082
版权

2-2为什么要继承

//Person.h文件

#include<string>
using namespace std;

class Person
{
public:
Person(); //构造函数
~Person();
void eat();
string m_strName;
int m_iAge;
};

//Work.h文件

#include"Person2_2.h"

class Worker:public Person //公有继承Person
{
public:
Worker();
~Worker();
void work();
int m_iSalary;
};

//Person.cpp文件

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

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

//Worker.cpp文件

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

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

//main文件

//C++远征之继承篇2-2为什么要继承
#include<iostream>
#include<stdlib.h>
#include"Worker2_2.h"
using namespace std;
/***************************/
/*
继承
要求：
1.定义Person类，要求含有m_strName和m_iAge两个数据成员
 及构造函数和析构函数、eat函数
2.定义Worker类，要求共有继承Person类，含有数据成员m_iSalary、构造函数
 析构函数、work函数
/***************************/
int main(void)
{
/* Worker *p = new Worker(); //结果：先执行父类的构造函数再执行派生类的构造函数
delete p; //释放内存时先释放派生类的内存再释放父类的内存
p = NULL; */


Worker *p = new Worker();
p->m_strName = "CJ";
cout<<"m_strName = "<<p->m_strName<<endl;
p->m_iAge = 10;
cout<<"m_iAge = "<<p->m_iAge<<endl;
p->eat();
p->m_iSalary = 5000;
cout<<"m_iSalary = "<<p->m_iSalary<<endl;
p->work();
delete p;
p = NULL;

system("pause");
return 0;
}


3-2公有继承

代码演示：

//Person.h文件

#include<string>
using namespace std;

class Person
{
public:
Person(); //构造函数
~Person();
void eat();
//private: //若申明为private则子类不可访问该数据成员
protected:
string m_strName;
int m_iAge;
};

//Worker.h文件

#include"Person3_2.h"
class Worker:public Person //公有继承Person
{
public:
Worker();
~Worker();
void work();
int m_iSalary;
};

//Person.cpp文件

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

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

//Worker.cpp文件

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


Worker::Worker()
{
cout<<"Worker()"<<endl;
}
Worker::~Worker()
{
cout<<"~Worker()"<<endl;
}
void Worker::work()
{
m_strName = "Merry";
m_iAge = 20;
cout<<"work()"<<endl;
}

//main文件

//C++远征之继承篇3-2公有继承代码演示
#include<iostream>
#include<stdlib.h>
#include"Worker3_2.h"
//#include"Person3_2.h"
using namespace std;
/***************************/
/*
继承
要求：
1.定义Person类，要求含有m_strName和m_iAge两个数据成员
 及构造函数和析构函数、eat函数
2.定义Worker类，要求共有继承Person类，含有数据成员m_iSalary、构造函数
 析构函数、work函数
/***************************/
int main(void)
{
Worker worker;
// worker.m_strName = "CJ";
// cout<<"m_strName = "<<worker.m_strName<<endl;
// worker.m_iAge = 10;
// cout<<"m_iAge = "<<worker.m_iAge<<endl;
// worker.eat();
// worker.m_iSalary = 5000;
// cout<<"m_iSalary = "<<worker.m_iSalary<<endl;
worker.work();  

/* Person person;

// person.m_strName = "Merry"; //错误
// person.eat(); */

system("pause");
return 0;
}

3-4保护继承和私有继承

//Perso3_4.h文件

//人类
#include<string>
using namespace std;
class Person
{
public:
Person();
void play();
protected:
string m_strName;
};

//Soldier3_4.h文件

//战士类
#include"Person3_4.h"

//class Soldier:public Person
//class Soldier:protected Person
class Soldier::private Person
{
public:
Soldier();
void work();
protected:
int m_iAge;
private:
};

//Infantry3_4.h文件

//步兵类
#include"Soldier3_4.h"

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

//Person3_4.cpp文件

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

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


//Soldier3_4.cpp文件

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

Soldier::Soldier()
{

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

//Infantry3_4.cpp文件

#include"Infantry3_4.h"
#include<iostream>
using namespace std;
void Infantry::attack()
{
m_strName = "Jim";
cout<<m_strName<<endl;
cout<<"Infantry--attack()"<<endl;
}

//main文件

//c++远征之继承篇3-4保护继承和私有继承
#include<iostream>
#include<stdlib.h>
//#include"Soldier3_4.h"
#include"Infantry3_4.h"
/**************************************/
/* 保护继承和私有继承
要求：1.Person类，数据成员：m_strName,成员函数：构造函数、play()
 2.Soldier类，数据成员：m_iAge,成员函数：构造函数，work()
 3.Infantry步兵类,成员函数：attack()
/**************************************/
int main(void)
{
/* Soldier soldier;
soldier.work();
soldier.play();
*/


Infantry soldier;
soldier.attack();


system("pause");
return 0;
}

4-2隐藏

//Soldier4_2.h

//战士类
#include"Person4_2.h"
class Soldier:public Person
//class Soldier:protected Person
//class Soldier::private Person
{
public:
Soldier();
void work();
void play();
protected:
string m_strName;
private:
};

//Person4_2.h

//人类
#include<string>
using namespace std;
class Person
{
public:
Person();
void play();
protected:
string m_strName;
};


//Soldier4_2.cpp

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

Soldier::Soldier()
{


}
void Soldier::work()
{
m_strName = "CJ";
Person::m_strName = "who_knows";
// cout<<m_strName<<endl;
cout<<"Soldier--work()"<<endl;
}
void Soldier::play()
{
cout<<m_strName<<endl;
cout<<Person::m_strName<<endl;
cout<<"Soldier play()"<<endl;
}


//Person4_2.cpp

#include<iostream>
#include"Person4_2.h"
using namespace std;
Person::Person()
{
m_strName = "Merry";
}
void Person::play()
{
cout<<"Person--play()"<<endl;
cout<<m_strName<<endl;
}

//main文件

//c++远征之继承篇4-2隐藏
#include<iostream>
#include<stdlib.h>
#include"Soldier4_2.h"
/**************************************/
/* 隐藏
要求：1.Person类，数据成员：m_strName,成员函数：构造函数、play()
 2.Soldier类，数据成员：无,成员函数：构造函数，play()、work()
/**************************************/
int main(void)
{
Soldier soldier;
soldier.work();
soldier.play();

soldier.Person::play();

system("pause");
return 0;
}

4-5isA

//Person4_5.h

//人类
#include<string>
using namespace std;
class Person
{
public:
Person(string name = "Jim");
virtual ~Person(); //有继承关系时，用虚析构函数
void play();
protected:
string m_strName;
};

//Soldier4_5.h

//战士类
#include"Person4_5.h"
class Soldier:public Person
//class Soldier:protected Person
//class Soldier::private Person
{
public:
Soldier(string name = "James",int age = 20);
virtual ~Soldier();
void work();
protected:
string m_iAge;
};


//Person4_5.cpp

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

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;
}

//Soldier4_5.cpp

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

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;
}

//main文件

//c++远征之继承篇4-5~4-6isA
#include<iostream>
#include<stdlib.h>
#include"Soldier4_5.h"
/**************************************/
/* 公有继承：Is a
要求：1.Person类，数据成员：m_strName,成员函数：构造函数、play()
 2.Soldier类，数据成员：m_iAge,成员函数：构造函数、构造函数，work()
 3.定义函数test1(Person p) test2(Person &p) test3(Person *p)
/**************************************/
void test1(Person p)
{
p.play();
}
void test2(Person &p)
{
p.play();
}
void test3(Person *p)
{
p->play();
}

int main(void)
{
/* Person p = soldier;
Person *p = new Soldier;
p->play();
delete p;
p = NULL; */

Person p;
Soldier s;
test3(&p);
test3(&s);

system("pause");
return 0;
}

5-2多重继承

//Person5_2.h

//人类
#include<string>
using namespace std;

class Person
{
public:
Person(string name = "Jim");
virtual ~Person();
void play();
protected:
string m_strName;
};

//Soldier5_2.h

//战士类
#include<string>
#include"Person5_2.h"
class Soldier:public Person
{
public:
Soldier(string name = "James",int age = 20);
virtual ~Soldier();
void work();
protected:
int m_iAge;
};

//Infantry5_2.h

//步兵类
#include<string>
#include"Soldier5_2.h"
class Infantry:public Soldier
{
public:
Infantry(string name = "Jack",int age = 30);
~Infantry();
void attack();
};

//Person5_2.cpp

#include<iostream>
#include"Person5_2.h"
using namespace std;
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;
}

//Soldier5_2.cpp

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

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;
}

//Infantry5_2.cpp

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

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

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

//main文件

//c++远征之继承篇5-2多重继承
#include<iostream>
#include<stdlib.h>
#include"Infantry5_2.h"
/**************************************/
/* 多重继承
要求：1.Person类，数据成员：m_strName,成员函数：构造函数、析构函数、play()
 2.Soldier类，数据成员：m_iAge,成员函数：构造函数、析构函数、work()
 3.Infantry步兵类,数据成员：无，成员函数：构造函数、析构函数、attack()
 4.定义函数test1(Person p),test2(Person &p),test3(Person *p)
/**************************************/
void test1(Person p)
{
p.play();
}
void test2(Person &p)
{
p.play();
}
void test3(Person *p)
{
p->play();
}

int main(void)
{
Infantry infantry;
test1(infantry);
test2(infantry);
test3(&infantry);
// soldier.attack();


system("pause");
return 0;
}

5-3多继承

//Farmer5_3.h

//5-3多继承
#include<string>
using namespace std;

class Farmer
{
public:
Farmer(string name = "Jack");
virtual ~Farmer();
void sow();
protected:
string m_strName;
private:
};

//Worker5_3.h

//5-3多继承
#include<string>
using namespace std;
class Worker
{
public:
Worker(string code = "001");
virtual ~Worker();
void carry();
protected:
string m_strCode;
};

//MigrantWorker5_3.h

//5-3多继承
#include<string>
#include"Farmer.h"
#include"Worker5_3.h"

class MigrantWorker:public Farmer,public Worker
{
public:
MigrantWorker(string name,string code);
~MigrantWorker();
protected:
};

//Farmer5_3.cpp

//5-3多继承
#include<iostream>
#include"Farmer.h"
using namespace std;

Farmer::Farmer(string name)
{
m_strName = name;
cout<<"Farmer()"<<endl;
}
Farmer::~Farmer()
{
cout<<"~Farmer()"<<endl;
}
void Farmer::sow()
{
cout<<m_strName<<endl;
cout<<"Farmer--sow"<<endl;
}

//Worker5_3.cpp

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

Worker::Worker(string code)
{
m_strCode = code;
cout<<"Worker()"<<endl;
}
Worker::~Worker()
{
cout<<"~Worker()"<<endl;
}
void Worker::carry()
{
cout<<m_strCode<<endl;
cout<<"Worker--carry()"<<endl;
}


//MigrantWorker5_3.cpp

//5-3多继承
#include"MigrantWorker.h"
#include<iostream>
using namespace std;
MigrantWorker::MigrantWorker(string name,string code):Farmer(name),Worker(code)
{
cout<<"MigrantWorker()"<<endl;
}
MigrantWorker::~MigrantWorker()
{
cout<<"~MigrantWorker()"<<endl;
}

//main

//5-3多继承
#include<iostream>
#include<stdlib.h>
#include"MigrantWorker.h"
/*******************************/
/*
多继承
要求：1.Farmer类，数据成员：m_strName,成员函数：构造函数、析构函数、sow()
 2.Worker类，数据成员：m_strCode,成员函数：构造函数、析构函数、carry()
 3.MigrantWorker类，数据成员：无，成员函数：构造函数、析构函数
/*******************************
int main(void)
{
MigrantWorker *p = new MigrantWorker("Merry","100");
p->carry();
p->sow();
delete p;
p = NULL;

system("pause");
return 0;
}

//6-2虚继承

//Farmer6_2.h

//6-2虚继承
#include"Person6_2.h"
#include<string>
using namespace std;

class Farmer:virtual public Person
{
public:
Farmer(string name = "Jack",string color = "blue");
virtual ~Farmer();
void sow();
protected:
string m_strName;
private:
};


//Worker6_2.h

//6-2多继承
#include"Person6_2.h"
#include<string>
using namespace std;
class Worker:virtual public Person
{
public:
Worker(string code = "001",string color = "blue");
virtual ~Worker();
void carry();
protected:
string m_strCode;
};


//MigrantWorker6_2.h

//6-2多继承
#include<string>
#include"Farmer6_2.h"
#include"Worker6_2.h"

class MigrantWorker:public Farmer,public Worker
{
public:
MigrantWorker(string name,string code,string color);
~MigrantWorker();
protected:
};

//Person6_2.h

#ifndef PERSON_H
#define PERSON_H

#include<string>
using namespace std;

class Person
{
public:
Person(string color = "blue");
virtual ~Person();
void printColor();
protected:
string m_strColor;
};

#endif


//Farmer6_2.cpp

//6-2多继承
#include<iostream>
#include"Farmer6_2.h"
using namespace std;

Farmer::Farmer(string name,string color):Person("Farmer"+color)
{
m_strName = name;
cout<<"Farmer()"<<endl;
}
Farmer::~Farmer()
{
cout<<"~Farmer()"<<endl;
}
void Farmer::sow()
{
cout<<m_strName<<endl;
cout<<"Farmer--sow"<<endl;
}

//Worker6_2.cpp

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

Worker::Worker(string code,string color):Person("Worker"+color)
{
m_strCode = code;
cout<<"Worker()"<<endl;
}
Worker::~Worker()
{
cout<<"~Worker()"<<endl;
}
void Worker::carry()
{
cout<<m_strCode<<endl;
cout<<"Worker--carry()"<<endl;
}

//MigrantWorker6_2.cpp

//6-2多继承
#include"MigrantWorker6_2.h"
#include<iostream>
#include<string>
using namespace std;

MigrantWorker::MigrantWorker(string name,string code,string color):Farmer(name,color),Worker(code,color)
{
cout<<"MigrantWorker()"<<endl;
}
MigrantWorker::~MigrantWorker()
{
cout<<"~MigrantWorker()"<<endl;
}


//Person6_2.cpp

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

Person::Person(string color)
{
m_strColor = color;
cout<<"Person()"<<endl;
}
Person::~Person()
{
cout<<"~Person()"<<endl;
}
void Person::printColor()
{
cout<<m_strColor<<endl;
cout<<"Person--printColor()"<<endl;
}


//main文件

//6-2虚继承
#include<iostream>
#include<stdlib.h>
#include"MigrantWorker6_2.h"
/*******************************/
/*
虚继承
要求：1.Farmer类，数据成员：m_strName,成员函数：构造函数、析构函数、sow()
 2.Worker类，数据成员：m_strCode,成员函数：构造函数、析构函数、carry()
 3.MigrantWorker类，数据成员：无，成员函数：构造函数、析构函数
 4.Person类，数据成员：m_strCode,成员函数：构造函数、析构函数、printColor()
/*******************************/
int main(void)
{
MigrantWorker *p = new MigrantWorker("Merry","200","yellow");
p->Farmer::printColor();
p->Worker::printColor();
delete p;
p = NULL;

system("pause");
return 0;
}

cj_who_knows
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++远征篇汇总
m0_54754302的博客
04-23 1291
C++远征篇汇总
工资计算（C++）
m0_73509997的博客
04-12 1271
计件工人B对应派生类BWorker（除了从基类中继承的成员函数与成员数据，新增成员数据：数量totalNumbers(long int)和每件提成every(long int)，成员函数：getSalary()用B的工资计算方式对工资赋值）计时工人C对应派生类CWorker（除了从基类中继承的成员函数与成员变量，新增成员变量：时间totalHours(long int)和每小时工资every(long int)，成员函数：getSalary()用C的工资计算方式对工资赋值）
第十一周项目二——职员有薪水了
Dream
05-20 357
/* *Copyright (c) 2014,烟台大学计算机学院 *All rights reserved. *文件名称: test.cpp *作 者:陈丹 *完成日期:2015年5月20日 *版本号:v1.0 * *问题描述:定义一个名为CPerson的类，有以下私有成员:姓名、身份证号、性别和年龄，成员函数：构造函数、析构函数、输出信息的函数。
C++习题 P141.10 某单位的职工工资包括基本工资Wage，岗位津贴Subsidy，房租Rent，水费WaterFee，电费ElecFee设计实验工资单位管理的类Salary
Xzz2019的博客
10-31 3210
#include <iostream> #include <string> using namespace std; class Salary { private: double wage, subsidy, rent, waterfee, elecfee; public: Salary(double WAGE, double SUBSIDY, double RENT, double WATERFEE, double ELECFEE) { wage = WAGE;
c++ 类对象成员工人类
dimrhyme的博客
12-05 587
Problem Description 设计工人类Worker，它具有姓名name，年龄age，工作部门dept，工资salary等数据成员。 其中，salary为Salary类型的数据，包括基本工资Wage，岗位工资Subsidy，房租Rent，水费WaterFee，电费ElecFee。 实发工资=Wage+Subsidy-Rent-WaterFee-ElecFee，用double RealSalary()成员函数计算。 Worker类用静态成员num统计工人的人数。 输出格式为：左对齐，每个输出项占10
9-C++远征之多态篇-学习笔记
weixin_34381666的博客
07-22 153
C++远征之多态篇 本文及代码收录于个人编程笔记(整理中,欢迎Star):https://github.com/mtianyan/Programming-Notebook 面向对象三大特征：封装，继承，多态 多态: 发出一条命令时，不同的对象接收到同样的命令做出的动作不同 多态篇会学习到的目录： 普通虚...
C++远征之继承篇学习笔记之一
07-21
本能文章是关于C++编程中关于继承的内容。
C++学习笔记之继承
01-08
继承：是类之间定义的一种重要关系。 按照生活中的思考方式的话，就是继承老一辈的手艺并且在新的一辈中得到创新与传承，这里只不过是用在了类的关系上面，即老类与新类，父类与子类 继承举例： //写一个继承 //父类...
C++学习笔记本
05-14
C++学习笔记C++学习笔记C++学习笔记C++学习笔记C++学习笔记
C++之继承思维导图的总结
最新发布
03-01
C++之继承思维导图的总结
编写教师和学生信息的程序
m0_45026390的博客
04-12 1724
编写教师和学生信息的程序 （1）定义一个抽象类Person，在Person类中声明两个属性：name和age，并设置其对应的getter方法，用于获取人的姓名和年龄；在Person类中声明一个有参构造方法，用于对Person类中的属性进行初始化；在Person类中声明一个say()方法和一个getContent()方法，在say()方法中调用getContent()方法。 （2）定义类 Student，并继承Person类。在Student类中声明一个属性score；声明Student类的构造方法并重写Pe
JAVA第十一次作业《类的继承》
夏佳怡的博客
04-13 853
什么是继承？ 多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个单独一个类即可。 多个类可以称为子类，单独这个类称为父类、超类或者基类。 子类可以直接访问父类中的非私有的属性和行为。 通过 extends 关键字让类与类之间产生继承关系。 class SubDemo extends Demo{} //SubDemo是子类，Demo是父类 继承有什么好处？ 提高代码的复用性。 让类与类之间产生了关系，是多态的前提。 继承的特点 1.Jav.
Java基础学习第三周总结
qq_43746718的博客
02-22 1148
一、知识点概括 1.面向对象 2.修饰符 1.写一个Worker类,并创建多个worker 对象。 I.为worker类添加三个私有属性: 1). Sting类型的name,表示人的姓名。 2). int 类型的 age,表示人的年龄。 3). double类型的salary,表示人的工资。 II.为worker 类添加两个构造方法: 1).公开无参构造方法 2).接受三个参数的构造方法...
《C++远征之起航篇》学习笔记
la_fe_的博客
04-25 722
1.1 C++简介 1.1.1 C与C++的关系 1.2 C++ IDE初体验 1.2.1 新建项目
10-C++远征之模板篇-学习笔记
weixin_33910137的博客
07-24 136
C++远征之模板篇 本文及代码收录于个人编程笔记(整理中,欢迎Star):https://github.com/mtianyan/Programming-Notebook 将会学到的内容： 模板函数 & 模板类 -> 标准模板类 友元函数 & 友元类 静态数据成员 & 静态成员...
C++远征_继承篇
一把健
05-01 238
继承篇 继承： class Worker: public Person { public: void work(); int m_iSalary; }; // Person -> 基类/父类 // Worker -> 派生类/子类 内存中的对象 实例化的过程 Worker *p = new Worker(); delete p; p = NULL; 实例化时会先调用 Per...
C++远征之起航篇
m0_45868903的博客
10-30 660
链接：https://www.imooc.com/learn/342 C++远征系列共7篇文章，学习此教程建议具备C语言基础，可参考作者C语言入门系列文章（预计一周内更新完毕）。 一.C++中新的特性 1.C++中新的数据类型 这样在C中定义一个真假类型，需要用int C++中引入新的数据类型的好处 2.新的初始化方法 3.随用随定义 二.C++的输入输出方式 endl可以理解为回车，不加endl也是可以输出的。 三.C++之命名空间 为什么要命名空间： 比如一栋大楼上有两个公司：A公司和B公司。A公司有一
8-C++远征之继承篇-学习笔记
weixin_33782386的博客
07-22 182
C++远征之继承篇 本文及代码收录于个人编程笔记(整理中,欢迎Star):https://github.com/mtianyan/Programming-Notebook 开篇介绍 整个C++远征计划: 起航->离港->封装->继承 mark 为什么要用继承？ 为什么要有继承？ 如何来...
c++远征之继承篇
Feng_8071的博客
09-25 380
一、继承 继承 子类是父类的子集 派生类——基类 = 子类——父类继承 ：创建时-》先构造基类再派生类 对象消亡时-》先析构派生类再析构基类几种继承方式区别： 无法直接访问protected、private,只能访问public二、隐藏和覆盖 覆盖是指派生类函数覆盖基类函数，特征是： （1）不同的范围（分别位于派生类与基类） ； （2）函数名字相同； （3）参数相
c++指针详解之提高篇
07-28
C知道：非常高兴能为您解答有关C++指针的问题！C++中的指针是一个重要的概念，它可以让我们直接访问内存地址，提高程序的灵活性和效率。以下是关于C++指针的一些详细讲解： 1. 指针的定义和声明：在C++中，我们可以...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值