C++ 运算符重载 简易代码 使用模板,使用友元函数重载!

运行环境：
WIN10
涉及工具：
VS
编程语言：
C、C++

以下为主题内容：

[C++] 纯文本查看 复制代码

#include<stdio.h>


class Number
{
private:
        int x = 0;
        int y = 0;
public:
        Number() {}                                                        //无参构造函数
        Number(int x, int y);                        //构造函数
        void NPrint();                                                        //成员函数
        void puls();                                                        //成员值 ++
        Number operator++(int);                //n++重载函数
        Number operator++();                        //++n重载函数
        Number operator+(const Number& ret1);        //加法运算符重载
        bool operator<(const Number& ret);        //两个类对象比大小

        template<class T>
        friend void SortByTemplate(T* arr, int length);                //定义友元函数 让排序函数可以调用类成员

        template<class T>
        friend void ArrPrint(T* arr, int length);                                        //定义友元函数 让打印函数可以调用类成员
};

template<class T>                                                                                        //如果需要替换两处,那就在定义一个class S 名字随便取
void SortByTemplate(T* arr, int length);                //使用模板实现两个类型用一个函数进行排序
template<class T>                //数组打印模板
void ArrPrint(T* arr, int length);

int main()
{
        Number n1(3, 3), n2(2, 2),n3;        //实现一个  对象 n1++ 的功能 ++运算符重载

        printf("\n打印n1成员初始化后的值\n");
        n1.NPrint();                                                                //打印n1成员的值
        
        n1.puls();                        //使用普通函数给n1成员进行++运算
        printf("\n打印普通函数给n1成员进行++运算的值\n");
        n1.NPrint();                        //打印n1成员++后的值
                
        n1++;                                //使用运算符重载进行++操作
        printf("\n打印n1++现在的值\n");
        n1.NPrint();                        //打印n1成员运算符重载++后的值

        ++n1;                                //使用运算符重载进行++操作
        printf("\n打印++n1现在的值\n");
        n1.NPrint();                        //打印n1成员运算符重载++后的值

        n3 = n1 + n2;        //使用重载运算符计算两个类成员的加法运算
        printf("\n打印n1现在的值\n");
        n1.NPrint();                        //打印n1现在的值
        printf("\n打印n2现在的值\n");
        n2.NPrint();                        //打印n2现在的值
        printf("\n打印n3=n1+n2现在的值\n");
        n3.NPrint();                        //打印n3=n1+n2现在的值
        
        //两个类比大小 并进行排序 ----------------------;
        Number s1(9, 9), s2(3, 3), s3(5, 5), s4(7, 7), s5(4, 4), s6(3, 3);
        Number arr[] = { s1,s2,s3,s4,s5,s6 };
        
        printf("\n结构体模板 Base类型排序前\n");
        ArrPrint(arr, 6);        

        SortByTemplate(arr, 6);
        printf("\n结构体模板 arr类型排序后\n");
        ArrPrint(arr, 6);

        return 0;
}

//Number operator++();                                                                单目运算符 前缀  ++n;
//Number operator++(int);                                                        单目运算符 前缀  n++;
//Number operator--();                                                                        --运算于++运算符使用方法一样
//Number operator+(const Number& p);                两个类成员相加
//Number operator-(const Number& p);                于加法用法一致
//Number operator*(const Number& p);                于加法用法一致
//Number operator/(const Number& p);                于加法用法一致
//bool operator>(const Number& p);
//bool operator<(const Number& p);
//bool operator==(const Number& p);
//
//
//运算符重载:给运算符对应一个具体的函数; 写代码的时候方便


Number::Number(int x, int y) //构造函数 初始化类成员
{
        this->x = x;
        this->y = y;
}

void Number::NPrint()        //Number成员函数 打印类成员
{
        printf("%d %d\n", x, y);
}

void Number::puls()        //Number成员执行++运算
{
        x++;
        y++;
}

Number Number::operator++(int)        //n++运算符重载 类成员执行++操作
{
        x++;
        y++;
        return *this;
}

Number Number::operator++()                //++n运算符重载
{
        x++;
        y++;
        return Number(x, y);                                        //与 return *this 一样
}

Number Number::operator+(const Number& ret)        //加法运算符重载
{
        Number sum;
        sum.x = this->x + ret.x;
        sum.y = this->y + ret.y;
        return sum;
}

bool Number::operator<(const Number& ret)        //两个类对象比大小 
{
        return this->x < ret.x&& this->y < ret.y;                //两个成员都比另一个对象的成员大就返回1
}

 //新建一个冒泡排序的模板  一会用这个模板给类对象排序
template<class T>                                                                                        //如果需要替换两处,那就在定义一个class S 名字随便取
void SortByTemplate(T* arr, int length)                        //使用模板实现两个类型用一个函数进行排序
{
        for (int i = 0; i < length; i++)
        {
                for (int j = 0; j < length; j++)
                {
                        if (arr[j] < arr[j + 1])
                        {
                                T temp = arr[j];
                                arr[j] = arr[j + 1];
                                arr[j + 1] = temp;
                        }
                }
        }
}

template<class T>                //数组打印模板
void ArrPrint(T* arr, int length)
{
        for (int i = 0; i < 6; i++)
        {
                printf("%d %d\n", arr[i].x, arr[i].y);
        }
}

学破解防逆向，知进攻懂防守！

谢谢分享

威武霸气！

没有比这个更强的啦！！！

大佬无敌

谢谢分享

gwgirl大神。你就是我的偶像！

谢谢分享

正符合我的需要，谢谢楼主