函数模板的覆盖

/* 函数模板的覆盖 */

#include<iostream>

// 函数模板可以实现通用，可以根据自有的数据类型进行优化


template<typename T>

void swap(T &a,T &b)
{
    std::cout << "通用函数模板" << std::endl;
    T temp;
    temp = a;
    a = b;
    b = temp;
}

void main()
{
    int num1 = 100;
    int num2 = 10;
    swap(num1,num2);// 实现交换
    std::cout << num1 << " " << num2 << std::endl; 

    char ch1 = 'Z';
    char ch2 = 'A';
    swap(ch1,ch2);
    std::cout << ch1 << " " << ch2 << std::endl; 

    std::cin.get();// 等价于getchar();
}

//----------------------------------------------------

// 结构体,可以直接赋值
// 类,所有成员都是共有的类型可以复制
class info
{
public:
    char name[40];
    double db;
    int data;
};

struct info
{
    char name[40];
    double db;
    int data;
};

template<typename T>
void swap(T &a,T &b)
{
    std::cout << "通用函数模板" << std::endl;
    T temp;
    temp = a;
    a = b;
    b = temp;
}


template<>// 模板覆盖，模板为空，明确类型 
void swap(info &info1,info &info2)
{
    std::cout << "特有函数模板" << std::endl;
    // 通用模板可以实现通用,针对自己的数据类型做出优化
    info temp = info1;
    info1 = info2;
    info2 = temp;
}



void main()
{
    info info1 = {"wuxl",20.9,10};
    info info2 = {"wuhr",9.3,1};
    swap(info1,info2);

    std::cout << info1.name << info1.db << info1.data <<std::endl;
    std::cout << info2.name << info2.db << info2.data <<std::endl;

    std::cin.get();

}

 

处理私有类的函数模板覆盖:

/* 处理私有类的函数模板覆盖 */

#include<iostream>
#include<string>


// 如果类有私有成员变量 不可以用{} 初始化
// 类的对象之间默认是可以直接赋值的
// 类,结构体都有一个默认的赋值操作 =  浅拷贝
// 深拷贝用的最多  函数模板的覆盖
class info
{
public:
    char name[40];
    char *p;
    int data;
private:
    int num;

public:
    void set(int X)
    {
        this->num = X;// 通过接口设置私有变量
    }
    
    int get()
    {
        return this->num;// 返回值 有副本机制
    }

    info()// 构造函数
    {
        num = 0;
    }

    ~info()// 析构函数
    {
        num = 0;
    }

};


template<>// 模板覆盖，模板为空，明确类型 
void swap(info &info1,info &info2)
{
    std::cout << "特有函数模板" << std::endl;
    // 通用模板可以实现通用,针对自己的数据类型做出优化
    info temp = info1;
    info1 = info2;
    info2 = temp;
}

// 函数对一个对象进行深拷贝 需要自己实现一个函数模板的重载
// 
void main()
{
    info info1;
    info info2;
    std::strcpy(info1.name,"wuxl");
    std::strcpy(info2.name,"nihao");
    info1.data = 102;
    info2.data = 201;
    info1.p = new char[10];
    std::strcpy(info1.p,"上海");
    info2.p = new char[100];
    std::strcpy(info2.p,"上海");
    info1.set(89);
    info2.set(98);

    swap(info1,info2);

    std::cout << info1.name << info1.data << info1.data << info1.get() <<std::endl;
    std::cout << info2.name << info2.data << info2.data << info2.get() <<std::endl;
    
    std::cout << info1.p << std::endl;
    std::cout << info2.p << std::endl;
    std::cin.get();

}