C++知识点案例 笔记-6

1.三种友元函数
-非模板友元函数
-约束模板友元函数
-非约束模板友元函数
2.非类型参数
3.模板特化

1.三种友元函数

=====三种友元函数=====
--1---非模板友元函数
#include<iostream>
using namespace std;
template<typename T>
class R
{
    T lin_number;
    static int count;
public:
    R(const T& t) :lin_number(t){ count++; }
    ~R(){count--;}
    friend void fun();//友元函数1
    friend void show(const R<T>& a);//友元函数2
};
template<typename T>
//初始化count
int R<T>::count = 0;
//定义函数
void fun()
{
  cout<< "int_count:" << R<int>::count << endl;
  cout<< "double_count:" << R<double>::count <<endl;
}

void show(const R<int>& a)
{
    cout<< "int_lin:" << a.lin_number <<endl;
}
void show(const R<double>& a)
{
    cout<< "double_lin:" <<a.lin_number <<endl;

}


int main()
{
    //调用函数1
    fun();
    //创建函数对象
    R<int> a(20);
    fun();
    R<double> b(50.2020);
    fun();

    show(a);
    show(b);

    return 0;



}

---2--约束模板友元函数
#include<iostream>
using namespace std;
//函数模板声名
template<typename T>
void fun();
template<typename T>
void show(T& a);
//类模板定义
template<typename U>
class R
{
    U lin_number;
    static int count;
public:
    R(const U& u) :lin_number(u){ count++; }
    ~R(){count--;}
    friend void fun<U>();//友元函数1
    friend void show<>(R<U>& a);//友元函数2
};
template<typename T>
int R<T>::count = 0;//初始化count
template<typename T>
void fun()
{
    cout<< "tl_size:" << sizeof(R<T>) <<endl;
    cout<< "tl_count:"  << R<T>::count  <<endl;
}

template<typename T>
void show(T& t)
{
    cout<< "TL-lin_number:" << t.lin_number <<endl;
}
int main()
{
    //调用int类型函数模板实例
    fun<int>();
    //创建函数对象  class R中对函数进行了限制（限制为U型）个人感觉约束之意就在此呀
    R<int>a(10);
    R<int>b(20);
    R<double>c(5.2);
    //调用show()输出类的数据成员信息
    show(a);
    show(b);
    show(c);

    fun<int>();
    fun<double>();

    return 0;

}

--3---非约束模板友元函数

#include<iostream>
using namespace std;
template<typename T>
class F
{
private:

    T lin_number;

public:
    F(const T& t):lin_number(t){};

    //类内部声名函数模板
    template<typename U,typename V>
    friend void show(U& u,V& v);



};
template<typename U,typename V>
void show(U& u,V& v)
{
    cout<< u.lin_number<< "==AND=="<< v.lin_number<<endl;
}

int main()
{

    F<int>a(10);
    F<int>b(20);
    F<double>c(5.2);

    show(a,b);
    show(a,c);


    return 0;

}

2.非类型参数

==非类型参数==
#include<iostream>
using namespace std;
template<typename T,unsigned size>
class Array
{

T arr[size];
public:
    T& operator[] (unsigned i)       //运算符重载
    {
        if (i >= size)
            cout<<"Out of the bound !" <<endl;
        else
        return arr[i];

    }
};

int main()
{

    Array<char,6>arr01;//定义长度为6的char类型数组
    Array<int,10>arr02;//定义长度为10的int类型数组

    arr01[0] = 'A';
    cout<< arr01[0] <<endl;                                 //如果此处输入的 下标 > = 6 则输出 Out of the bound !

    for(int j = 0;j < 10;j++)
    {
        arr02[j] = j;
    }
    for(int k = 0;k < 10;k++)
    {
        cout<< arr02[k] <<"_";
    }


    return 0;

}

3.模板特化

==模板特化==

#include<iostream>
#include<cstring>
using namespace std;
template<typename T>
//定义函数模板
bool is_equal(T m,T n)
{
    return m == n;
}
//函数模板的特化
template<>
bool is_equal(char* t1,char* t2)
{
    return strcmp(t1 , t2) == 0;
}
//类模板
template<typename T>
class Compare
{
public:
    bool is_equal(T m,T n)
    {
        return m == n;
    }

};
//类模板的特化
template<>
class Compare<char*>
{
public:
    bool is_equal(char* t1,char* t2)
    {
        return strcmp(t1 , t2) == 0;
    }


};

int main()
{

    char str1 = 'jjf';
    char str2 = 'zl';

    cout<< "函数模板=AND=函数模板特化：" <<endl;

    cout<< is_equal(1,3) <<endl;
    cout<< is_equal(str1,str2) <<endl;

    cout<< "类模板=AND=类模板特化：" <<endl;
    Compare<int> c1;
    Compare<char> c2;
    cout<< c1.is_equal(1,1)<<endl;
    cout<< c2.is_equal(str1,str2)<<endl;

    return 0;

}