C++元编程语言初步入门详解

更新时间：2021年10月21日 11:33:36 作者：微小冷

这篇文章主要为大家介绍了C++元编程语言初步入门的详解示例，文中包含详细的基本概念及运用示例，有需要的朋友可以借鉴参考下，希望能够有所帮助

模板

由于模板元编程需要以面向对象为基础，所以如有疑问之处可以先补充一点C++面向对象的知识：

C++面向对象这一篇就够了

泛型初步

由于C++是静态强类型语言，所以变量一经创建，则类型不得更改。如果我们希望创建一种应用广泛地复数类型，那么相应地需要基于int、float、double这些基础类型逐一创建，十分麻烦。泛型编程便是为了简化这一过程而生。

能够容纳不同数据类型作为成员的类被成为模板类，其基本方法为在类声明的上面加上一行模板声明代码

template<typename T>，下一行为class myClass，其调用过程为myClass<T> m。

列举案例如下

#include<iostream>
using namespace std;
template<typename C>
struct Abstract{
    C real;         //real为C类型
    C im;
    Abstract(C inReal, C inIm){
        real = inReal;
        im = inIm;
    }
    void printVal(){
        cout<<"Abstract:"<<real<<"+"<<im<<"i"<<endl;
    };
    Abstract& multi(Abstract val){
        C temp = real*val.real - im*val.im;
        im = real*val.real + im*val.im;
        real = temp;
        return *this;
    };
};
int main(){
    Abstract<float> fTemp{1,2};//C类型为float
    fTemp.multi(fTemp);
    fTemp.printVal();
    system("pause");
    return 0;
}

函数模板

当然，上述multi并不能实现两个不同类型的Abstract之间的相乘，所以可以将multi函数改为

    template<typename T>
    Abstract<C>& multi(Abstract<T> val){
        C temp = real*val.real - im*val.im;
        im = real*val.real + im*val.im;
        real = temp;
        return *this;
    }

这样就能够实现如下功能。

int main(){
    Abstract<float> fTemp{1,2};
    Abstract<int> iTemp{1,2};
    fTemp.multi(iTemp);
    fTemp.printVal();
    getReal(fTemp);
    system("pause");
    return 0;
}

友元

模板类具备一部分普通类的性质，比如struct和class的区别，public、protected、private的性质，以及友元等。模板的声明特性也可以应用在函数中，例如

#include<iostream>
using namespace std;
template<typename C>
class Abstract{
    C real;
    C im;
public:
    Abstract(C inReal, C inIm){
        real = inReal;
        im = inIm;
    }
    void printVal(){
        cout<<"Abstract:"<<real<<"+"<<im<<"i"<<endl;
    };
    Abstract& multi(Abstract val){
        C temp = real*val.real - im*val.im;
        im = real*val.real + im*val.im;
        real = temp;
        return *this;
    }
    template<typename T> friend void getReal(Abstract<T> num);  //声明友元
};
template<typename C>
void getReal(Abstract<C> num){
    cout<<num.real<<endl;
}
int main(){
    Abstract<float> fTemp{1,2};
    fTemp.multi(fTemp);
    fTemp.printVal();
    getReal(fTemp);
    system("pause");
    return 0;
}

需要注意的一点是，在模板类中声明友元，其前缀<typename T>中的类型标识不得与已有的类型标识重复，否则编译无法通过。

由于函数模板可以针对不同的数据类型进行求解操作，是对函数或者方法实例的抽象，所以又被称为算法。

模板参数

如果将模板理解为一种类型声明的函数，那么模板也应该具备一些函数具备的功能。首先其模板参数中可以包含实际类型参数，例如

template<typename T, int max>
class Test{}

其调用时可以写为

Test<int,256> pixel;

模板同样支持默认参数，即可以实现如下形式

template<typename T=int, int max=256>
class Test{}
Test pixle;

除了数据类型、值之外，模板本身也可以作为模板参数，例如下面的形式是合法的。

template<typename T, template<typename> class C>
struct Test{
    C<T>* val;
    Test(C<T>* inVal){
        val = inVal;
    }
};
int main(){
    Abstract<int> fTemp{1,2};
    Test<int,Abstract> test(&fTemp);
    test.val->printVal();
    system("pause");
    return 0;
}

其结果为

PS E:\Code\cpp> g++ .\generic.cpp
PS E:\Code\cpp> .\a.exe
Abstract:1+2i
请按任意键继续. . .

需要注意的一点是，在模板类中定义的模板类，需要进行实例化，否则会出现错误，所以在Test中，以指针形式创建了模板类。

类型函数

以数据类型为输入或输出的函数即为类型函数，在C语言中，sizeof便是一种类型函数，其输入为数据类型，输出为数据类型所需要的内存空间。

在C++11中，using可以实现数据类型赋予的功能，其使用方法与typedef相似

template<typename T>
struct Test{
    using type = T;
}

元编程的基本概念

元编程是泛型编程的一个超集，两者的本质均是针对不同数据类型的算法，后者则更关注传入参数的广泛性。如果将元编程分为四个层次

无计算
运算符连接的运算
编译时具备选择等非递归计算
编译时具备递归运算

那么泛型编程可以作为第一类元编程，或者说更加关注的是参数的传入传出过程，而元编程则更关注不同数据类型的选择过程。

例如，我们可以实现一个最多包含三个元素的元组Tuple，其思路为，三元元素可以看成是一个二元元组与一个参数的组合；二元元组可以看成是一元元组与参数的组合；一元元组则是一个基本数据类型的变量。在这个元组的实现过程中，除了赋值过程实现泛型之外，也需要判断当前所实现的元组元素个数，如果其初始化参量为3个时，需要递归式地创建变量，直到赋值参数为1个。则其实现如下

class Nil{};
//主模板
template<typename T1=Nil, typename T2=Nil, typename T3=Nil>
struct Tuple : Tuple<T2,T3>{
    T1 x;
    using Base = Tuple<T2,T3>;      //三元元组以二元元组为基础
    //返回值为Tuple<T2,T3>指针类型的base()函数
    //static_cast将this转化为Base*类型
    Base* base(){return static_cast<Base*>(this);}
    const Base* base() const {return static_cast<const Base*>(this);}
    //构造函数继承二元元组，在构造本类中x的同时，构造基类Tuple<T2,T3>
    Tuple(const T1& t1, const T2& t2, const T3& t3)
        :Base{t2,t3},x{t1}{}
};
template<typename T1>
struct Tuple<T1>{
    T1 x;
};
template<typename T1, typename T2>
struct Tuple<T1,T2> : Tuple<T2>{
    T1 x;
    using Base = Tuple<T2>;
    Base* base(){return static_cast<const Base*>(this);}
    const Base* base() const {return static_cast<const Base*>(this);}
    Tuple(const T1& t1,const T2& t2):Base{t2}, x{t1}{}
};
template<typename T1, typename T2, typename T3>
void print_elements(ostream& os, const Tuple<T1,T2,T3>& t){
    os<<t.x<<",";
    print_elements(os,*t.base());
}
template<typename T1, typename T2>
void print_elements(ostream& os, const Tuple<T1,T2>& t){
    os<<t.x<<",";
    print_elements(os,*t.base());
}
template<typename T1>
void print_elements(ostream& os, const Tuple<T1>& t){
    os<<t.x;
}
//运算符重载
template<typename T1, typename T2, typename T3>
ostream& operator<<(ostream& os, const Tuple<T1,T2,T3>& t){
    os<<"{";
    print_elements(os,t);
    os<<"}";
    return os;
}
int main(){
    Tuple<int,double,char> x{1,2.5,'a'};
    cout<<x<<endl;
    system("pause");
    return 0;
}

其输出结果为

PS E:\Code\cpp> g++ .\generic.cpp
PS E:\Code\cpp> .\a.exe
{1,2.5,a}

可变参数模板

上述实现过程非常繁琐，而且限制了元组中的元素个数，如果标准库中用上述的书写风格，那么标准库除了这个元组之外也写不了其他的东西了。好在C++模板提供了可变参数的功能，例如，我们可以先将打印模板函数写为

//typename... T 代表可变参数
template<typename T1, typename... T>
void print_elements(ostream& os, const Tuple<T1,T...>& t){
    os<<t.x<<",";
    print_elements(os,*t.base());
}
template<typename T1>
void print_elements(ostream& os, const Tuple<T1>& t){
    os<<t.x;
}
template<typename... T>
ostream& operator<<(ostream& os, const Tuple<T...>& t){
    os<<"{";
    print_elements(os,t);
    os<<"}";
    return os;
}

其输出结果为

PS E:\Code\cpp> g++ .\generic.cpp
PS E:\Code\cpp> .\a.exe
{1,2.5,a}
请按任意键继续. . .

然后将Tuple也做相同的更改

template<typename T1, typename... T>
struct Tuple : Tuple<T...>{
    T1 x;
    using Base = Tuple<T...>;      //N+1元元组以N元元组为基
    Base* base(){return static_cast<Base*>(this);}
    const Base* base() const {return static_cast<const Base*>(this);}
    //注意T&...的书写格式
    Tuple(const T1& t1, const T&... t):Base{t...},x{t1}{}
};
template<typename T>
struct Tuple<T>{
    T x;
};
/*
    print模板
*/
int main(){
    Tuple<string, double,int,char> tt("hello",1.5,1,'a');
    cout<<tt<<endl;
    system("pause");
    return 0;
}

其输出结果为

PS E:\Code\cpp> g++ .\generic.cpp
PS E:\Code\cpp> .\a.exe
{hello,1.5,1,a}

以上就是C++元编程语言初步入门详解的详细内容，更多关于C++元编程语言初步的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

C语言数据结构二叉树之堆的实现和堆排序详解
堆是计算机科学中一类特殊的数据结构的统称，通常是一个可以被看做一棵完全二叉树的数组对象。而堆排序是利用堆这种数据结构所设计的一种排序算法。本文将详细介绍堆的实现和堆排序，需要的可以参考一下
2022-04-04
C语言函数栈帧的创建与销毁详解
函数栈帧（stack frame）就是函数调用过程中在程序的调用栈（call stack）所开辟的空间,下面这篇文章主要给大家介绍了关于C语言函数栈帧的创建与销毁的相关资料,文中通过实例代码介绍的非常详细,需要的朋友可以参考下
2022-09-09
C++计算圆形、矩形和三角形的面积
这篇文章介绍了C++计算圆形、矩形和三角形面积的方法，文中通过示例代码介绍的非常详细。对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
2022-01-01
C/C++实现枚举网上邻居信息的示例详解
在Windows系统中,通过网络邻居可以方便地查看本地网络中的共享资源和计算机,本文将介绍一个简单的C++程序,使用Windows API枚举网络邻居信息,并获取对端名称、本机名称、主机名称以及主机IP等信息,文中通过代码示例给大家讲解非详细,需要的朋友可以参考下
2023-12-12
C语言中的字符型数据与ASCII码表
这篇文章主要介绍了C语言中的字符型数据与ASCII码表，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2023-01-01
C语言中字符串处理函数sscanf的用法
一直对于一些日期字符串中数字的提取比较头疼,现看到 sscanf 对于字符串中的内容提取较方便,本文主要介绍了C语言中字符串处理函数sscanf的用法,具有一定参考价值,感兴趣的可以了解一下
2023-08-08
一文详解如何在VS Code上搭建C/C++开发环境
VSCode是由微软开发的一款免费、开源、跨平台的文本编辑器,它具有许多强大的功能,这篇文章主要给大家介绍了关于如何在VS Code上搭建C/C++开发环境的相关资料,文中通过图文介绍的非常详细,需要的朋友可以参考下
2024-03-03
C语言算法积累加tag的循环队列
这篇文章主要为大家介绍了C语言算法积累加tag的循环队列的解题思路，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
2022-06-06
break的使用for循环嵌套示例
这篇文章主要介绍了break的使用for循环嵌套示例,需要的朋友可以参考下
2014-02-02
函数外初始化与函数内初始化详细解析
函数内初始化：bool FillStr(char *&szDst, int nSize);第一个参数中的&一定不能少，这是因为在函数外部我们只声明了这个指针，具体这个指针指向内存中的哪个地址我们并不知道，所以&是为了说明传递的是这个指针的引用，那么在函数内初始化后这个指针的地址也就是外面指针的地址了
2013-09-09