侧边栏壁纸
  • 累计撰写 278 篇文章
  • 累计创建 3 个标签
  • 累计收到 1 条评论

目 录CONTENT

文章目录

【C++】C++模板知识点总结

xuanxuan
2021-09-26 / 0 评论 / 0 点赞 / 3 阅读 / 8803 字 / 正在检测是否收录...
温馨提示:
本文最后更新于 2024-02-14,若内容或图片失效,请留言反馈。部分素材来自网络,若不小心影响到您的利益,请联系我们删除。

@TOC

function template

函数模板就是建立一个通用的函数,其函数类型和形参类型不具体指定,用一个虚拟的类型来代表。这个通用函数就称为函数模板。

template< typename T >(class和typename都行)

参数类型自动推导
    Max(x,y);
显示类型调用
    Max<int>(x,y);

template function

调用函数模板,编译器私底下会 根据传过来的变量创建对应的函数,将它具体化。——这就是通过编译生成的模板函数。


小结:

  1. 我们注意到,函数模板和函数重载似乎很类似,当他们两个并存时,如果参数类型和普通函数更匹配,就调用普通函数。
  2. 不存在普通函数,函数模板会隐式类型转换吗?不会。不提供隐式的类型转换,必须是严格的匹配。
  3. 如果显式的调用函数模板,则使用<>类型列表。
  4. 如果函数模板会产生更好的匹配,使用函数模板。
  5. 当所传参数需要隐式类型转换时,优先调用普通函数。
  6. 函数模板也可以重载。
  7. 编译器并不是把函数模板处理成能够处理任意类型的函数。
  8. 编译器从函数模板通过具体的参数类型产生不用的函数。

class template

类模板创建对象,必须显式指定类型。


类模板用于实现类所需数据的类型参数化。

类模板在表示支持多种数据结构显得特别重要,这些数据结构的表示和算法不受所包含的元素类型的影响。


类模板与继承

1.父类是一般类,子类时模板类,和普通继承类似。

2.子类是一般类,父类是模板类, 继承时必须在子类中实例化父类参数。

例如:

template <typename T>
class   A
{
public:
    A(T t = 0) :t(t)
    {

    }
    ~A()
    {

    }
    T getT()const
    {
        return this->t;
    }
private:
    T t;
};

class B:public A<int>
{
public:
    B(int b = 0) :A<int>(b)
    {

    }

private:
    int b;
};

3.父类和子类都是模板时,子类的虚拟类型可以传递到父类中。


类模板的写法注意

  1. 写在类外面时,要加参数列表, 并且要声明模板(class name< 参数列表 >)
  2. 类模板定义和声明分开写,包含主函数的.cpp 要包含"该类声明的.cpp"

书写实例: (就是基本上只要在类外写定义的有类名的位置后面都要写上< T >,除了构造析构函数,其实写上也没事,只是警告让用新的书写形式。)

(不建议使用太多的友元函数)

类模板和友元函数

在类外实现成员函数要先声明一下模板

#include<iostream>
using namespace std;

template<typename T>
class A
{
public:
    A(T a= 0);
    T& getT()const;
    A operator+(const A& other);
    void print()const;
    ~A();
    //友元函数在类中声明也要加上模板的声明
    template<typename T>
    friend A<T> addA(const A<T>& a, const A<T>& b);
private:
    T t;
};

template<typename T>
A<T>::A(T a) : t(a)
{

}
template<typename T>
A<T>::~A()
{

}
template<typename T>
A<T> A<T>::operator+(const A<T>& other)
{
    A<T> tmp;
    tmp.t = this->t + other.t;
    return tmp;
}
template<typename T>
void A<T>::print()const
{
    cout << this->t << endl;
}

template<typename T>
T& A<T>::getT()const
{
    return this->t;
}

template<typename T>
A<T> addA(const A<T>& a, const A<T>& b)
{
    A<T> temp;
    temp.t = a.t + b.t;
    return temp;

}

int main(void)
{
    A<int> a(100);
    a.print();

    A<int> b(200);
    A<int>temp = addA<int>(a,b);
    temp.print();
    return 0;
}

小结

  1. 类模板内部声明友元函数,也要声明一下模板先。
  2. 类模板成员函数内部从创建的对象别忘了加< T >。
  3. 友元函数调用,函数名后也要显示指定类型。

类模板和static数据成员

类外赋初值

template<typename T>
int A<T>::count = 666;

虚拟类型T被实例化的类型不同,所调用的内容也不同。

注意以下代码的静态变量变化即可了解。

同意类模板的虚拟类型T被实例化的类型相同,静态变量是同一个。

    A<int>a(100);
    A<int>b(200);
    a.count = 888;
    cout << a.count << endl;
    cout << b.count << endl;

    A<float>c(1.0);
    A<float>d(2.0);
    cout << c.count << endl;
    cout << d.count << endl;

静态成员数据也可以使用虚拟类型参数。

效果同上。

public:
    static T count;

小补充:

类的成员函数不能调用我们下面成员函数重载的运算符。(貌似)


类模板重载左移 在声明中加一个< T >,让编译通过。

template<typename T>
friend ostream& operator<< <T>(ostream& out, const Vector<T>& object);

(自定义)容器中放入类,该类需要有默认构造函数。

自定义容器中存放自定义类对象,该容器重载了<<,想要按照下标cout<<,那么该类也要重载<<。


练习:实现一个自定义Vector类

Vector.h

#include <iostream>

using namespace std;

template <typename  T>
class Vector
{
    template<typename T>
    friend ostream& operator<< <T>(ostream& out, const Vector<T>& object);
public:
    Vector(int size = 128); 
    Vector(const Vector& object); 
    int getLength();
    T& operator[](int index);
    Vector& operator=(const Vector& object);
    ~Vector(); /

private:
    T* m_base;
    int m_len;
};

Vector.cpp

#include <iostream>
using namespace std;
#include "Vector.h"

template<typename T>
ostream& operator<<(ostream& out, const Vector<T>& object) 
{
    for (int i = 0; i < object.m_len; i++)
    {
        out << object.m_base[i] << " ";
    }
    out << endl;

    return out;
}

template <typename T>
Vector<T>::Vector(int size)
{ 
    if (size > 0) {
        m_len = size;
        m_base = new T[m_len];
    }
}

template <typename T>
Vector<T>::Vector(const Vector<T>& object) 
{ 

    m_len = object.m_len;
    m_base = new T[m_len];
    for (int i = 0; i < m_len; i++) 
     {
        m_base[i] = object.m_base[i];
    }
}
template <typename T>
int Vector<T>::getLength() 
{
    return m_len;
}

template <typename T>
T& Vector<T>::operator[](int index) 
{
    return m_base[index];
}

template <typename T>
Vector<T>& Vector<T>::operator=(const Vector<T>& object)
{
    if (m_base != NULL) 
      {
        delete[] m_base;
        m_base = NULL;
        m_len = 0;
    }
    m_len = object.m_len;
    m_base = new T[m_len];
    for (int i = 0; i < m_len; i++) 
      {
        m_base[i] = object.m_base[i];
    }
    return *this; 
}

template <typename T>
Vector<T>::~Vector()
{ 
    if (m_base != NULL) 
    {
        delete[] m_base;
        m_base = NULL;
        m_len = 0;
    }
}

main.cpp

#include"Vector.cpp"
#include<iostream>
#include<string>
using namespace  std;

class Student {
public:
    Student() {
        age = 0;
        name = '\0';
    }

    Student(int _age, string _name):name(_name),age(_age)
    {
    }

    void print() {
        cout << name << ", " << age << endl;
    }

    ~Student() {

    }
    friend ostream& operator<<(ostream& os, const Student& stu);

private:
    string name;
    int age;
};

ostream& operator<<(ostream& os, const Student& stu)
{
    os << stu.age << " " << stu.name << endl;
    return os;
}

int main(void)
{

    Student s1(18, "张三");
    Student s2(18, "张四");

    Vector<Student> myStudent(2);
    myStudent[0] = s1;
    myStudent[1] = s2;
    for (int i = 0; i < myStudent.getLength(); i++)
    {
        cout << myStudent[i] << endl;
     }

    //Vector<int> myVector(10);
    //for (int i = 0; i < myVector.getLength(); i++)
    //{
    //  myVector[i] = i;
    //}
    //for (int i = 0; i < myVector.getLength(); i++)
    //{
    //  cout << myVector[i] << endl;
    //}
    //cout << "——————————————" << endl;

    //Vector<int>MyintVector(myVector);
    //for (int i = 0; i < myVector.getLength(); i++)
    //{
    //  cout << MyintVector[i] << endl;
    //}
    //cout << "——————————————" << endl;

    //Vector<float>MyFloatVector(10);
    //for (int i = 0; i < MyFloatVector.getLength(); i++)
    //{
    //  MyFloatVector[i] = i * 0.1f;
    //}
    //for (int i = 0; i < MyFloatVector.getLength(); i++)
    //{
    //  cout << MyFloatVector[i] << endl;
    //}

    //myVector = MyintVector;
    //cout << "——————————————" << endl;

    //for (int i = 0; i < myVector.getLength(); i++)
    //{
    //  cout << MyintVector[i] << endl;
    //}
    //cout << "——————————————" << endl;
    //cout << "——————————————" << endl;
    //cout << "——————————————" << endl;
    //cout << MyintVector;

    return 0;
}
0

评论区