达州做网站
大橙子网站建设，新征程启航
为企业提供网站建设、域名注册、服务器等服务
c++-模板-创新互联
c++-模板
网站栏目：c++-模板-创新互联
文章路径：http://dzwzjz.com/article/pegpe.html
- 函数模板
- 类模板
- 模板重载
- 参数类型推断
- 类型转换
- 显示指明
- 模板进阶 -- 还没看
相当于函数重载的进阶，类型参数化
数据的类型也可以通过参数传递
在函数定义时可以不指明具体的数据类型，当发生函数调用时，编译器根据传入的实参自行推断数据类型，相当于类型参数化
函数模板
建立一个通用函数，用到的数据类型（返回值、形参类型、局部变量类型）无需具体指定，用一个标识符来站位，等发生函数调用时再根据传入的实参来逆推出真正的类型
一旦定义类函数模板，就可以将类型参数 用于函数定义和函数声明，（将内置类型的地方，用类型参数来代替）
template函数模板关键字<>占位符typename T声明具体的类型参数，类型参数是Ttemplate模板头，模板头中包含的类型参数可以用在函数定义的各个位置，包括返回值、形参列表和函数体
#includeusing namespace std;
templateT mmax(T a,T b);
templatevoid swap(T *a,T *b) // templatevoid swap(T *a,T *b) 也是可以的
{T temp=*a;
*a=*b;
*b=temp;
}
template// 可换行，但不能有分号
T mmax(T a,T b)
{if (a>=b)
return a;
else
return b;
}
int main()
{int a=10,b=20;
swap(&a,&b);
cout< 类模板中定义的类型参数可以在类声明和类定义中
templateclass MyPoint
{private:
T1 x;
T2 y;
public:
MyPoint(T1 x,T2 y);
void setx(T1 x);
T1 getx() const;
void sety(T2 y);
T2 gety() const; // const 成员函数 不能修改成员this的成员值
MyPoint *print() const;
};
templateMyPoint::MyPoint(T1 x,T2 y)
{this->x=x;
this->y=y;
}
templatevoid MyPoint::setx(T1 x)
{this->x=x;
}
templatevoid MyPoint::sety(T2 y)
{this->y=y;
}
templateT1 MyPoint::getx() const
{return this->x;
}
templateT2 MyPoint::gety() const
{return this->y;
}
templateMyPoint* MyPoint::print() const
{return new MyPoint(this->x,this->y);
}
int main()
{// 创建对象
MyPointp1(1,2);
MyPointp2(3.,4.);
MyPointp3(5,"lisi");
// 创建对象
MyPoint*p4=new MyPoint(6,7);
// 接收返回值
MyPoint*point_ptr=p1.print();
cout<getx()<<" "<gety()<*point_ptr2=p2.print();
cout<getx()<<" "<gety()< 例子2 !!!
#includeusing namespace std;
templateclass List
{private:
int length; // 数组个数
T *ptr; //数组指针
public:
List(int length);
List(List &arr); // 构造函数重载
~List();
void push_back(const T &v); // 添加元素
// List & operator=(const List &a); // 数组见赋值， 成员函数，返回的是引用
T size();
T & operator[](int idx); // 成员函数，返回的是引用
};
templateList::List(int length)
{this->length=length;
if (length==0)
{this->ptr=NULL;
}
else
{this->ptr=new T[this->length]();
}
}
templateList::List(List &arr)
{if (!arr.ptr)
{this->ptr==NULL;
this->length=0;
return ; // 这个也很重要
}
this->ptr=new T[arr.length];
memcpy(this->ptr,arr.ptr,sizeof(T)*arr.length); // 内存赋值
this->length=arr.size;
}
templateList::~List()
{if (this->ptr)
{delete[] this->ptr;
}
cout<<"析构"<void List::push_back(const T &v)
{if (this->ptr)
{// 注意写法！！！
T *temp_ptr=new T[this->length+1](); // 重新分配空间
memcpy(temp_ptr,this->ptr,sizeof(T)*this->length); // 拷贝原有数组;
delete[] this->ptr;
this->ptr=temp_ptr;
}
else
{this->ptr=new T[1]();
}
this->ptr[this->length++]=v;
}
templateT List::size()
{return this->length;
}
templateT & List::operator[](int idx)
{return this->ptr[idx];
}
int main()
{ListL(3);
cout< #includeusing namespace std;
templatevoid mswap(T &a,T &b);
templatevoid mswap(T a[],T b[],int len);
templatevoid printArray(T arr[],int len);
int main()
{int a=10,b=20;
cout<1,2,3};
int arr2[3]={4,5,6};
cout<<"******"<void mswap(T &a,T &b)
{T temp=a;
a=b;
b=temp;
}
templatevoid mswap(T a[],T b[],int len)
{T temp;
for (int i=0;itemp=a[i];
a[i]=b[i];
b[i]=temp;
}
}
templatevoid printArray(T arr[],int len)
{for (int i=0;icout< templatevoid func(T a, T b);
func(1,2.3); // 错误不能进行隐式的类型转换，且不知道T应该是哪个类型
templatevoid func(T a);
int a[10];
func(a); // T的类型为int *, 会进行类型转换
templatevoid func(T &a);
int a[10];
func(a); // 当函数参数是引用类型时，数组不会转换为指针，T的类型为int [10] 注意
当显示指明类型参数时，可以进行类型转换（隐式）
templatevoid func(T a, T b);
func(1,2.3); // 正确的 // 函数调用过程中只能推断出T1 不能推断出 T2，所以必须显示指明
templatefunc(T1 a)
{T2 b;
}
// 显示指明是，是按顺序指明的
func(10) 7.6
你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧
网站栏目：c++-模板-创新互联
文章路径：http://dzwzjz.com/article/pegpe.html