运算符重载_继承_多态_模版

1：运算符重载

 

 

 

RMB.h
#ifndef RMB_H
#define RMB_H

#include <bits/stdc++.h>
using namespace std;
class RMB
{
    public:
        RMB();
        RMB(int, int);
        virtual ~RMB();
        void display()
        {
            cout << "RMB:" << yuan << ".";
            if(jf < 10)
            {
                cout << "0";
            }
            cout << jf << endl;
        }
        friend RMB operator+(const RMB&, const RMB&);//作为友元函数的元素符重载
        friend bool  operator>(const RMB&, const RMB&);
        int Getjf() { return jf; }
        void Setjf(int val) { jf = val; }
        int Getyuan() { return yuan; }
        void Setyuan(int val) { yuan = val; }
        RMB operator+(const RMB& s)//作为成员函数的运算符重载
        {
            int c = this->jf + s.jf;
            int d = this->yuan + s.yuan;
            return RMB(c,d);
        }
    protected:

    private:
        int jf;
        int yuan;
};

#endif // RMB_H
RMB.cpp
/*
 * 文件名：
 * 描  述：
 * 作  者：
 * 时  间：
 * 版  权：
 */#include "RMB.h"
#include <bits/stdc++.h>
using namespace std;
RMB::RMB()
{
    cout << "RMB construction" << endl;
}
RMB::RMB(int _yuan, int _jf):yuan(_yuan),jf(_jf)
{
    cout << "RMB(int, int) construction" << endl;
}
RMB::~RMB()
{
    cout << "RMB destruction"  << endl;
}

RMB operator+(const RMB& val1,const RMB& val2)//重载加运算符
{
    int jf = val1.jf + val2.jf;
    int yuan = val1.yuan + val2.yuan;
    if(jf > 99){
        yuan++;
        jf-=100;
    }
    return RMB(yuan, jf);//局部对象不可以返回引用
}

bool operator>(const RMB& val1, const RMB& val2)//判断大小
{
    bool ret =false;
    if(val1.yuan > val2.yuan)
    {
        ret = true;
    }else if(val1.yuan == val2.yuan){
        if(val1.jf > val2.jf)
            {
                ret  = true;
            }
    }
    return ret;
}

main.cpp
#include <iostream>
#include "RMB.h"
using namespace std;

int main()
{

    RMB rmb1(12,13);
    RMB rmb2(9,9);
    cout << (rmb1 > rmb2) << endl;
    RMB rmb3 = rmb1 + rmb2;
    cout << rmb3.Getyuan() << "  " << rmb3.Getjf() << endl;
    rmb3.display();
    return 0;
}

 

可以进行运算符重载的运算符

不可以进行运算符重载的运算符 

 

 更详细的的运算符重载的内容可以点击这篇博客

2：继承

 

 

 

 

 关于继承的详细知识可以看这篇博客

 关于继承的基础知识可以看这篇博客

Animal.h
#ifndef ANIMAL_H
#define ANIMAL_H

#include<bits/stdc++.h>
using namespace std;
class Animal
{
    public:
        Animal();
        virtual ~Animal();
        virtual void bark()
        {
            cout << "动物发出叫声" << endl;
        }
        unsigned int Getheight()const { return height; }
        void Setheight(unsigned int val) { height = val; }

    protected:

    private:
        unsigned int height;
};
class dog:public Animal//单继承
{
public:
    dog(){};
    dog(unsigned int height,unsigned int weight):weight(weight)
    {
        Setheight(height);
       // height = height;
        //weight = weight;
    }
    unsigned int getWeight()const
    {
        return weight;
    }
    void setWeight(int w){
      weight = w;
    }
    virtual void bark()
    {
        cout << "狗儿汪汪叫" << endl;
    }
private:
    unsigned int weight;
};
class littleDog : public Animal,public dog//多继承
{
public:
    littleDog(unsigned int height,unsigned int weight)
    {
        setWeight(weight);
    }
private:

};
#endif // ANIMAL_H
Animal.cpp
/*
 * 文件名：
 * 描  述：
 * 作  者：
 * 时  间：
 * 版  权：
 */#include "Animal.h"

Animal::Animal()
{
    //ctor
}

Animal::~Animal()
{
    //dtor
}
main.cpp
#include <iostream>

using namespace std;
#include <Animal.h>
int main()
{
    dog d(70,70);
    d.bark();//虚函数，重写父类版本
    d.Animal::bark();//强制调用father中定义的版本
    cout << d.Getheight() << d.getWeight() << endl;
    //d.dogbark();
    littleDog  ld(12,12);
    cout << ld.getWeight() << endl;
    return 0;
}

3：多态

 

这篇博客讲了多态的基础

这一篇做了很好的总结 

4：类模版

#include<bits/stdc++.h>
using namespace std;
template <class T>
class Stack
{
public:
    Stack():top(0)
    {
        array[top] = 0;
    }
    void push(const T&i);
    T pop();
private:
    enum{SIZE = 100};
    T array[SIZE];
    int top;
};
template<typename T>
void Stack<T>::push(const T& val)
{
    if(top < SIZE){
        array[top++] = val;
    }
}
template<typename T>
T Stack<T>::pop()
{
    if(top > 0)
    return array[--top];
    else array[0];
}
int main()
{
    Stack<int> a;
    a.push(1);
    a.push(3);
    a.push(2);
    cout << a.pop() << endl;
    cout << a.pop() << endl;
    cout << a.pop() << endl;
}

提高了代码的复用性