斗破C++目录:
斗破C++编程入门系列之前言(斗之气三段)
斗破C++编程入门系列之二:Qt的使用介绍(斗之气三段)
斗破C++编程入门系列之三:数据结构(斗之气三段)
斗破C++编程入门系列之四:运算符和表达式(斗之气五段)
斗破C++编程入门系列之五:算法的基本控制结构之选择结构(斗之气八段)
斗破C++编程入门系列之六:算法的基本控制结构之循环结构(斗之气八段)
斗破C++编程入门系列之七:自定义数据类型(斗之气八段)
斗破C++编程入门系列之八:函数的定义与调用(斗之气八段)
斗破C++编程入门系列之九:函数重载与模板函数(斗之气九段)
斗破C++编程入门系列之十:类与对象:类的声明、成员的访问控制和对象(二星斗者)
斗破C++编程入门系列之十一:类与对象:构造函数和析构函数(四星斗者)
斗破C++编程入门系列之十二:类与对象:类的组合(五星斗者)
斗破C++编程入门系列之十三:类与对象:类模板(六星斗者)
斗破C++编程入门系列之十四:C++程序设计必知:作用域和可见性(六星斗者)
斗破C++编程入门系列之十五:C++程序设计必知:变量生存期(六星斗者)
斗破C++编程入门系列之十六:C++程序设计必知:类的静态成员(九星斗者)彩蛋)
斗破C++编程入门系列之十七:C++程序设计必知:友元(九星斗者)彩蛋)
斗破C++编程入门系列之十八:C++程序设计必知:常引用、常对象(九星斗者)彩蛋)
斗破C++编程入门系列之十九:C++程序设计必知:多文件结构和编译预处理命令(九星斗者)
斗破C++编程入门系列之二十:数组、指针和字符串:数组的声明和使用(一星斗师)
斗破C++编程入门系列之二十一:数组、指针和字符串:数组的存储与初始化、对象数组、数组作为函数参数(一星斗师)
斗破C++编程入门系列之二十二:数组、指针和字符串:指针变量的声明、地址相关运算–“*”和“&”(一星斗师)
斗破C++编程入门系列之二十三:数组、指针和字符串:指针的赋值和指针运算(一星斗师)
斗破C++编程入门系列之二十四:数组、指针和字符串:指向数组元素的指针和指针数组(一星斗师)
斗破C++编程入门系列之二十五:数组、指针和字符串:指针用作函数参数、指针型函数和函数指针(一星斗师)
斗破C++编程入门系列之二十六:数组、指针和字符串:动态内存分配和释放(一星斗师)
斗破C++编程入门系列之二十七:数组、指针和字符串:string类(一星斗师)
斗破C++编程入门系列之二十八:继承与派生:概念介绍与派生类的声明(一星斗师)
斗破C++编程入门系列之二十九:继承与派生:派生类从基类继承的过程(一星斗师)
斗破C++编程入门系列之三十:继承与派生:派生类对基类成员的访问控制之公有继承(一星斗师)
斗破C++编程入门系列之三十一:继承与派生:派生类对基类成员的访问控制之保护继承与私有继承(一星斗师)
斗破C++编程入门系列之三十二:继承与派生:派生类的构造函数(一星斗师)
斗破C++编程入门系列之三十三:继承与派生:派生类的析构函数(一星斗师)
斗破C++编程入门系列之三十四:继承与派生:作用域分辨符(四星斗师)
斗破C++编程入门系列之三十五:继承与派生:虚基类及其派生类的构造函数(四星斗师)
斗破C++编程入门系列之三十六:继承与派生:赋值兼容规则(四星斗师)
斗破C++编程入门系列之三十七:多态性:运算符重载的概念和规则(四星斗师)
鸡啄米C++
记住首页不迷路:
http://www.jizhuomi.com/software/129.html
斗破观看顺序:
https://v.haohuitao.cc/yhplay/336-1-2.html
第一季☞第二季前2集☞特别篇1☞第二季3~12集☞特别篇2沙之澜歌☞第三季☞第四季☞三年之约☞缘起☞年番
斗气大陆等级:
斗气有十一个阶别,斗之气,斗者,斗师,大斗师,斗灵,斗王,斗皇,斗宗,斗尊,斗圣,斗帝。
斗气大陆上很久没有出现过斗帝了。
一、解救青鳞
墨家的宴席正在进行中,但是苦苦寻找青鳞不得的萧炎,没有办法只能在家宴中质问墨承,并揭露墨承人面兽心的一面。
正当墨家准备与众人一起商议筹建墨盟的时候,萧炎与海老正步走到门前,第一个拒绝了墨承的阴谋诡计。墨承一开始还极力隐瞒,但是当海老将密室中的试验品公之于众时,墨承脑凶成怒,迅速变形成了不人不兽的怪物,为了增强实力,竟然生生将众多盟友及家仆吞噬。
但是由于实力悬殊,墨承仍然不是萧炎与海老的对手,为了进一步提升实力,墨承决定去密室将青鳞吞噬,当萧炎与海老追至密室门口,却被一个紫色的保护罩阻挡,正当萧炎与海老不知如何之时,一个神秘女子却带着青鳞似箭簇穿出,萧炎与海老追了过去,同时还有气急败坏的墨承,后续故事如何发展,请听下回分解。
二、C++:多态性:运算符重载的概念和规则
我们使用“+”、“-”、“*”、“/”其实就是在执行相对应的函数,所以运算符重载本身其实就是一种函数重载。因为普通的运算符函数已经被定义好了,所以我们可以直接使用,但是其他自定义的类就没那么友好了,需要我们自己定义,我们来看代码:
#ifndef PERSON_H
#define PERSON_H
#include <QString>
#include <QDebug>
#include <Monster.h>
#include <Skill.h>
#include <creature.h>
//定义人的类型,有使用成员函数,则定义为class
template <typename T>
class Person : virtual public Creature
{
//析构函数
public:
~Person(){
qDebug() << name << "的空间准备被释放掉";
}
public:
//自定义的构造函数
//template <typename T>
Person(QString name, int age, int level)
: Creature("unknown")
{
if(name == "xioayan"){
qDebug() << "开始创建萧炎";
}
else if(name == "xuner"){
qDebug() << "开始创建熏儿";
}
else{
qDebug() << "开始创建" << name;
}
this->name = name;
this->age = age;
this->level = level;
//每有一个对象被创建,则count+1;
count++;
qDebug() << "创建 " << name
<< " count " << count;
}
public:
QString name; //名字
int age; //年龄
T level; //斗之气等级
//斗技
Skill skill;
//静态成员变量
static int count; //被创建的对象总数
public:
//成员函数
template <typename T>
bool fight(Monster monster){
qDebug() << "monster level" << monster.level;
if(this->level > monster.level){
return true;
}
else{
return false;
}
}
template <typename T>
Person<T> operator + (Person<T>){
return *this;
}
};
//自定义Person<T>类的自增运算符
//参数中含int表示是后增,不加表示前增
template <typename T>
Person<T> operator++(Person<T> &person, int){
qDebug() << "等级提升前" << person.level;
person.level += 1;
qDebug() << "等级提升后" << person.level;
return person;
}
#endif // PERSON_H
调用时如下:
#include "mainwindow.h"
#include <QApplication>
#include <QDataStream>
#include <QDebug>
#include <person.h>
#include <Function.h>
#include <queen.h>
//类模版的静态成员初始化
//静态成员初始化只能在函数体外
template <typename T>
int Person<T>::count=0;
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
MainWindow w;
w.show();
//指定模版类型
Person<double> xiaoyan("xiaoyan",17,8); //萧炎
{
//加了大括号之后,都是xiaoyan,但是不冲突,
//括号内的xiaoyan与括号外的无关系
Person<double> xiaoyan("xiaoyan2",18,9); //萧炎
}
test_survival_period();
Person<double> xuner("xuner", 16, 15);
qDebug() << "萧炎目前的斗之气等级 " << xiaoyan.level;
level_up(xiaoyan);
qDebug() << "升级后的斗之气等级 " << xiaoyan.level;
//使用重载函数,连升3级别
level_up(xiaoyan,3);
qDebug() << "升级后的斗之气等级 " << xiaoyan.level;
Monster snake; //岩蛇
snake.name = "snake";
snake.level = 1;
qDebug() << "岩蛇目前的斗之气等级 " << snake.level;
level_up(snake);
qDebug() << "岩蛇升级后的斗之气等级 " << snake.level;
//指定模版类型
bool outcome = xiaoyan.fight<double>(snake);
qDebug() << "萧炎与岩蛇的战斗结果 " << outcome;
qDebug() << "萧炎目前的斗技 " << xiaoyan.skill.name;
//斗技
Skill skill;
skill.name = "八级崩";
//赋值给萧炎新的斗技
xiaoyan.skill = skill;
qDebug() << "萧炎目前的斗技 " << xiaoyan.skill.name;
//这里把level_up的参数改成了常引用,
//试试编译有报错吗?
//这里定义一个常对象
const bool victory = true;
//修改victory看看编译有报错吗?
//victory = false;
//使用数组
//Person<double>* person_set[3];
//Skill skill_set[3];
Skill skill_1("吸掌");
Skill skill_2("八级崩");
Skill skill_3("爆步");
/*
skill_set[0] = skill_1;
skill_set[1] = skill_2;
skill_set[2] = skill_3;
for(int i=0; i<3; i++){
qDebug() << "i " << i
<< skill_set[i].name;
}
*/
//数组初始化
Skill skill_set[3] = {skill_1 , skill_2, skill_3};
for(int i=0; i<3; i++){
qDebug() << "i " << i
<< skill_set[i].name;
}
//数组作为参数
print_all_skill(skill_set, 3);
//非指针类型对象
Person<double> Frank("Frank",35,9);
//指针类型对象
Person<double>* Yao_lao = new Person<double>("yaolao",45,88);
qDebug() << " Frank is Pointer ? " << isPointer(Frank);
//使用&将普通对象转为指针类型。
Person<double>* Frank_copy = &Frank;
qDebug() << " Frank_copy is Pointer ? " << isPointer(Frank_copy);
qDebug() << " Yao_lao is Pointer ? " << isPointer(Yao_lao);
//使用*转换为普通对象
qDebug() << " Yao_lao is Pointer ? " << isPointer(*Yao_lao);
//使用自增和自减操作指针
Skill* p = skill_set;
qDebug() << "p " << p->name;
p++;
qDebug() << "p " << p->name;
p++;
qDebug() << "p " << p->name;
//定义一个指针数组
Person<double>* person_set[3];
person_set[0] = new Person<double>("小医仙",18,6);
person_set[1] = new Person<double>("萧鼎",19,16);
person_set[2] = new Person<double>("萧厉",18,15);
qDebug() << person_set[0]->name << " level " << person_set[0]->level;
qDebug() << person_set[1]->name << " level " << person_set[1]->level;
qDebug() << person_set[2]->name << " level " << person_set[2]->level;
//函数名为指针,
//定义指针的类型为:bool can_find_fire(Person<double> * person)
// 使用std::function声明一个函数指针
std::function<bool(Person<double>*)> func = can_find_fire;
//调用func
func(person_set[0]);
//释放指针占用的内存
delete person_set[0];
delete person_set[1];
delete person_set[2];
//创建女王对象
Queen meidusha;
//女王调用远古灵蛇的斗技
meidusha.use_ancient_fighting_skill();
//创建怪物类
Monster monkey;
monkey.name = "岩猿";
monkey.level = 1;
//女王调用人类的函数打怪兽
meidusha.fight<double>(monkey);
//调用与父类相同的成员函数
meidusha.use_ancient_fighting_skill();
//调用与父类相同的成员变量
qDebug() << " meidusha.name " << meidusha.name;
//调用自己的函数
meidusha.use_secret_skill();
//看看编译会不会报错,美杜莎能否使用远古灵蛇的private属性函数
//meidusha.use_ancient_unique_skill();
//美杜莎使用与远古天蛇同名的函数
meidusha.AncientSnake::use_ancient_fighting_skill();
//
meidusha.grow_up();
//meidusha.Person<double>::grow_up();
//meidusha.AncientSnake::grow_up();
//meidusha.born_place;
//赋值兼容
Creature father_1 = meidusha; //看看是否可以编译通过
Creature * father_2 = &meidusha; //看看是否可以编译通过
Creature & father_3 = meidusha; //看看是否可以编译通过
father_1.grow_up();
father_2->grow_up();
//father_3.use_secret_skill(); //看看是否可以编译通过
//使用自定义的运算符
xiaoyan++;
return a.exec();
}
这里注意,自增运算符的重载写在类外,写在内类没有效果,大家可以试试。
三、英语
先来看几个单词:
- overloaded function 重载函数
- operator 运算符
再来看几个句子:
- However(然而), due to(由于) the disparity(差距) in strength(在力量方面), Mo Cheng(墨承) is still(仍然) not(不是) a match(对手) for(对于) Xiao Yan(萧炎) and(和) Hai Lao(海老).
- 但是由于实力悬殊,墨承仍然不是萧炎与海老的对手。
however 汉语中意思是“然而”。
due to 短语意思是“由于”。