C++ 可变模版的高级使用，模仿python plot输入参数写法

最新推荐文章于 2023-08-23 16:26:58 发布
最新推荐文章于 2023-08-23 16:26:58 发布
阅读量174 收藏
点赞数 1
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/github_39582118/article/details/117599907
版权

C++ 可变模版非常方便，可以实现任意数量的参数输入，下面用C++可变模版模仿python matplotlib.pyplot.plot 函数，实现任意数量参数输入，并且识别输入变量的类型

类型定义

用宏定义定义一些结构体，实现marker、linewidth等标记类型和变量

#define MO_KEYWORD_INPUT(name, type)                                                                                                  \
namespace tag{                                                                                                                        \
    struct name {                                                                                                                     \
        typedef type        Type;                                                                                                     \
        typedef const Type& ConstRef;                                                                                                 \
        typedef Type&       Ref;                                                                                                      \
        typedef ConstRef    StorageType;                                                                                              \
        typedef const void* VoidType;                                                                                                 \
        template <typename T>                                                                                                         \
        static PLT_CONSTEXPR bool AllowedType() { return std::is_same<Type, T>::value; }                                              \
        static VoidType GetPtr(ConstRef arg) {                                                                                        \
            return &arg;                                                                                                              \
        }                                                                                                                             \
        template <class T>                                                                                                            \
        static VoidType GetPtr(const T& arg) {                                                                                        \
            (void)arg;                                                                                                                \
            return nullptr;                                                                                                           \
        }                                                                                                                             \
    };                                                                                                                                \
}                                                                                                                                     \
namespace PLT_ARG_NAMESPACE {                                                                                                         \
    static kwargs::TKeyword<tag::name>& name = kwargs::TKeyword<tag::name>::instance;                                                 \
}

上面的PLT_ARG_NAMESPACE命名空间定义了static类型为tag::name的变量name，赋值的是instance变量，注意，instance变量是结构体TKeyword类型，其中instance成员是static类型，这意味着所有的name共享同一个TKeyword类型

namespace kwargs {
    struct TaggedBase {};
    template <class Tag>
    struct TaggedArgument : public TaggedBase {
        typedef Tag TagType;
        explicit TaggedArgument(typename Tag::StorageType val)  //explicit显示赋值，避免隐式赋值
                : arg(&val) {
        }

        typename Tag::VoidType get() const {
            return arg;
        }

    protected:
        typename Tag::VoidType arg;
    };

    template <class Tag>
    struct TKeyword {
        static TKeyword     instance;   //初始化后所有类的instance共享同一个TKeyword类
        TaggedArgument<Tag> operator=(typename Tag::StorageType data) {
            return TaggedArgument<Tag>(data);
        }
    };
    template <class T>
    TKeyword<T> TKeyword<T>::instance;
}

声明

MO_KEYWORD_INPUT 定义了结构体类型marker、label等，并在PLT_ARG_NAMESPACE命名空间定义了类型为TKeyword的marker、label等变量。

MO_KEYWORD_INPUT(marker,std::string)
MO_KEYWORD_INPUT(label, std::string)
MO_KEYWORD_INPUT(color, std::string)
MO_KEYWORD_INPUT(linewidth, int8_t)
MO_KEYWORD_INPUT(alpha, float )
MO_KEYWORD_INPUT(edgecolor, std::string)
MO_KEYWORD_INPUT(markersize, double )
#define DEFAULT_LEGEND      ""
#define DEFAULT_MARKER      "-"
#define DEFAULT_ALPHA       1.0f
#define DEFAULT_COLOR       "none"
#define DEFAULT_EDGECOLOR   "none"
#define DEFAULT_LINEW       2
#define DEFAULT_MARKERSZ    6.0f

可变模版函数的展开

定义函数plotxy，输入x，y坐标，后面的参数包则为曲线的相关设置。

template <class ... Args>
void plotxy(int x,int y,const Args&... args)
{
   auto marker =  GetKeywordInputDefault<tag::marker>(DEFAULT_MARKER,args...);
   std::cout << "maker:"<<marker << endl;
   auto makersize = GetKeywordInputDefault<tag::markersize>(DEFAULT_MARKERSZ,args...);
   cout << "msize:" << makersize << endl;
   auto lw = GetKeywordInputDefault<tag::linewidth>(DEFAULT_LINEW,args...);
   cout << "lw:" << (int)lw << endl;
}

下面的类型Tag是结构体类型，如tag::marker，GetKeywordInputDefault函数第一个参数是默认值DEFAULT_MARKER，第二个参数是参数包，调用GetKeyImpl展开参数包args

template <class Tag, bool Infer = false, class... Args>
typename Tag::ConstRef GetKeywordInputDefault(typename Tag::ConstRef def, const Args&... args) {

    const void* ptr = GetKeyImpl<Tag, Infer>(args...);
    if (ptr)	//如果返回值不是0，表示在参数包args中知道了对应类型的参数
        return *static_cast<const typename Tag::Type*>(ptr);
    //args中没有找到Tag类型的参数，返回默认值
    return def;
}

参数包展开的终止函数
template <class Tag, bool Infer = false>
typename Tag::VoidType GetKeyImpl() {   //如果没有找到与def类型一致的类，返回0
    return 0;
}

template <class Tag, bool Infer = false, class T, class... Args>
//kwargs::TaggedBase是类T的基类，则is_base_of为真，则enable_if<true,T>::type为T::type,即定义GetKeyImpl返回值为Tag::VoidType类型
typename std::enable_if<std::is_base_of<kwargs::TaggedBase, T>::value, typename Tag::VoidType>::type
GetKeyImpl(const T& arg, const Args&... args) {
	//如果Tag与T::TagType类型相同，则返回arg的值，否则继续调用GetKeyImpl展开参数包
    return std::is_same<typename T::TagType, Tag>::value ? const_cast<void*>(arg.get()) : const_cast<void*>(GetKeyImpl<Tag, Infer, Args...>(args...));
}

完整代码

#include <iostream>
#include "type_traits"

using namespace std;

#define PLT_CONSTEXPR constexpr
#ifndef PLT_ARG_NAMESPACE
#define PLT_ARG_NAMESPACE
#endif

#define MO_KEYWORD_INPUT(name, type)                                                                                                  \
namespace tag{                                                                                                                        \
    struct name {                                                                                                                     \
        typedef type        Type;                                                                                                     \
        typedef const Type& ConstRef;                                                                                                 \
        typedef Type&       Ref;                                                                                                      \
        typedef ConstRef    StorageType;                                                                                              \
        typedef const void* VoidType;                                                                                                 \
        template <typename T>                                                                                                         \
        static PLT_CONSTEXPR bool AllowedType() { return std::is_same<Type, T>::value; }                                              \
        static VoidType GetPtr(ConstRef arg) {                                                                                        \
            return &arg;                                                                                                              \
        }                                                                                                                             \
        template <class T>                                                                                                            \
        static VoidType GetPtr(const T& arg) {                                                                                        \
            (void)arg;                                                                                                                \
            return nullptr;                                                                                                           \
        }                                                                                                                             \
    };                                                                                                                                \
}                                                                                                                                     \
namespace PLT_ARG_NAMESPACE {                                                                                                         \
    static kwargs::TKeyword<tag::name>& name = kwargs::TKeyword<tag::name>::instance;                                                 \
}

namespace kwargs {
    struct TaggedBase {};
    template <class Tag>
    struct TaggedArgument : public TaggedBase {
        typedef Tag TagType;
        explicit TaggedArgument(typename Tag::StorageType val)  //explicit显示赋值，避免隐式赋值
                : arg(&val) {
        }

        typename Tag::VoidType get() const {
            return arg;
        }

    protected:
        typename Tag::VoidType arg;
    };

    template <class Tag>
    struct TKeyword {
        static TKeyword     instance;   //初始化后所有类的instance共享同一个TKeyword类
        TaggedArgument<Tag> operator=(typename Tag::StorageType data) {
            return TaggedArgument<Tag>(data);
        }
    };
    template <class T>
    TKeyword<T> TKeyword<T>::instance;
}

MO_KEYWORD_INPUT(marker,std::string)
MO_KEYWORD_INPUT(label, std::string)
MO_KEYWORD_INPUT(color, std::string)
MO_KEYWORD_INPUT(linewidth, int8_t)
MO_KEYWORD_INPUT(alpha, float )
MO_KEYWORD_INPUT(edgecolor, std::string)
MO_KEYWORD_INPUT(markersize, double )
#define DEFAULT_LEGEND      ""
#define DEFAULT_MARKER      "-"
#define DEFAULT_ALPHA       1.0f
#define DEFAULT_COLOR       "none"
#define DEFAULT_EDGECOLOR   "none"
#define DEFAULT_LINEW       2
#define DEFAULT_MARKERSZ    6.0f

template <class Tag, bool Infer = false>
typename Tag::VoidType GetKeyImpl() {   //如果没有找到与def类型一致的类，返回0
    return 0;
}

template <class Tag, bool Infer = false, class T, class... Args>
typename std::enable_if<std::is_base_of<kwargs::TaggedBase, T>::value, typename Tag::VoidType>::type
GetKeyImpl(const T& arg, const Args&... args) {
    return std::is_same<typename T::TagType, Tag>::value ? const_cast<void*>(arg.get()) : const_cast<void*>(GetKeyImpl<Tag, Infer, Args...>(args...));
}

template <class Tag, bool Infer = false, class... Args>
typename Tag::ConstRef GetKeywordInputDefault(typename Tag::ConstRef def, const Args&... args) {

    const void* ptr = GetKeyImpl<Tag, Infer>(args...);
    if (ptr)
        return *static_cast<const typename Tag::Type*>(ptr);
    return def;
}


template <class ... Args>
void plotxy(int x,int y,const Args&... args)
{
   auto marker =  GetKeywordInputDefault<tag::marker>(DEFAULT_MARKER,args...);
   std::cout << "maker:"<<marker << endl;
   auto makersize = GetKeywordInputDefault<tag::markersize>(DEFAULT_MARKERSZ,args...);
   cout << "msize:" << makersize << endl;
   auto lw = GetKeywordInputDefault<tag::linewidth>(DEFAULT_LINEW,args...);
   cout << "lw:" << (int)lw << endl;
}

struct learn{
    static learn l; //static类成员，所有l变量共享同一地址
    static int count;
};

int learn::count = 100; //静态成员需要外部初始化

int main() {
//    learn l1;
//    l1.count = 10;
//    learn l2;
//    cout << "l1.cnt:" << l1.count << "  " << "l2.cnt:" << l2.count << endl;

    plotxy(0,0,marker="--",markersize=10.1);


    return 0;
}

代码来源

参考了用Qtchart写matplotlib相似功能的代码，项目为madplotlib

燎原之心
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
PlotX:这是一个类似于pgplot的类似于matplotlib的c ++包装器！
04-06
情节X 这是一个类似于pgplot的类似于matplotlib的c ++包装器！ 依存关系 pgplot 安装 ./bootstrap ./configure --prefix = [安装路径] 制作 进行安装 用法 检查examples目录中的一些。
c++绘图软件
01-24
一款简单的绘图软件，代码量少，但功能却非常强大，且启动很方便，作为一个学习的参考还是很不错的
C++实现Python变量
liaoyoujinb的专栏
11-14 1526
C++实现Python变量         仔细想想，其实所有分配在栈和静态存储区的存储空间都是由一个变量来标识，这是由系统自己管理的内存空间，而堆上分配的空间在每次运行期都是不一样的，也就是不是编译期决定的，所以只能用指针来标识。那么我们是否可以将这种指针标识的内存空间标量化，对象化呢？其实是可以的，事实上python就是这么做的。通过采用引用计数的方式来管理这段内存。我们现在要来实现这样
c++调用Matlab函数画图
05-23
c++调用Matlab函数画图，示例代码，具体过程参照我的博客中的两篇文章
plot：C ++的仅标头终端绘图库
02-06
C ++终端绘图库 警告：该库正在开发中！ 仅标头。 编译具有C ++ 14支持的示例； 与-lm链接（需要gcc / libstdc ++> = 4.9；已通过gcc 4.9，gcc 6.0和clang 3.9测试）。 该库尝试自动检测终端功能； 建议使用xterm兼容终端。 提供了一个CMake构建环境，该环境将构建示例并将标头打包到单个标头库中。 请注意，当前不支持非POSIX平台（例如Windows），并且它们的编译将失败。 包装头 pack.py是一个Python脚本，可以将所有标头打包到单个标头库中。 以下命令将生成一个头文件（ plot_lib.hpp ），准备将其包含
python matplotlib.pyplot.plot()参数用法
01-20
参数是一个可变长度参数，允许多个X、Y对可选的格式字符串。 例如，下面的每一个都是合法的： plot(x, y) #plot x, y使用默认的线条样式和颜色 plot(x, y, ‘bo’) #plot x,y用蓝色圆圈标记 plot(y) #plot y用x作为...
修改python plot折线图的坐标轴刻度方法
01-21
修改python plot折线图的坐标轴刻度，这里修改为整数： 代码如下： from matplotlib import pyplot as plt import matplotlib.ticker as ticker import numpy as np def std_plot(): overall_std = [34.369, 21....
ecg_plot:使用 Python 绘制标准多导联 ECGEKG 图
05-29
输入数据应为 mxn 矩阵，其中 m 为心电图导联数，n 为单导联信号长度。 默认采样率为 500 Hz。 例子 绘制 12 导联心电图 参数： 范围 描述 心电图 mxn 心电信号数据，m 为导联数，n 为信号长度。 采样率 信号的...
Python使用matplotlib绘制三维参数曲线操作示例
09-18
主要介绍了Python使用matplotlib绘制三维参数曲线操作,结合实例形式分析了Python使用matplotlib的数值计算与图形绘制相关操作技巧,需要的朋友可以参考下
利用C++设计一个简单的绘图软件
09-06
开发一个小型绘图应用程序,具体要求如下: （1）具有标准Windows应用程序的界面和风格(视图要求滚动)； （2）通过选择菜单或工具栏中相应功能完成基本几何图形的绘制(基本几何图形包括直线、圆、椭圆、矩形等); （3）几何图形实现存盘和读取显示功能; （4）应用程序界面友好;
C++绘图介绍（用C++在屏幕上绘图）
07-14
用VC++在屏幕上绘图用VC++在屏幕上绘图用VC++在屏幕上绘图用VC++在屏幕上绘图用VC++在屏幕上绘图用VC++在屏幕上绘图用VC++在屏幕上绘图用VC++在屏幕上绘图
MatPlot工具包C++
12-16
C++ 画图库 MatPlot; 别人的工具包，免费下载地址为：http://littleshi.cn/blog/MatPlot_Install/MatPlotTest.zip 使用说明地址：http://littleshi.cn/blog/MatPlot_Install/ CSDN里面选不了免金币下载。故不得不收1个金币。见谅
visual c++ plot实时曲线显示，可以动态显示当前采集值
09-08
visual c++ plot实时曲线显示，可以动态显示当前采集值
C++实现类似画图工具
08-18
用C++基于MFC库类实现类似WINDOWS的画图工具，能过实现部分功能~·
C++ 调用Gnuplot实现图形绘制的过程
weijimin1的博客
10-20 8673
C++ 调用Gnuplot实现图形绘制的过程 安装Gnuplot sudo apt-get install gnuplot sudo apt-get install gnuplot-x11 测试 输入gnuplot 出现命令行，输入 plot sin(x) 画一条正弦曲线 如图 出现上述图说明gnuplot库安装成功 下载gnuplot-cpp 下载地址 https://storage.googleapis.com/google-code-archive-dow...
c++ 实现绘图功能
热门推荐
何以诚的专栏
01-09 7万+
运行结果 #include "plotter.h" #include #include "PlotSettings.h" #include #include #include #include #include #include #include const QColor plotter::s_colorForIds[COLOR_FOR_IDS_SIZE] = { Q
matplotlib.pyplot用c++画图
wangjl2416的博客
03-02 3256
matplotlibcpp画图，搬运工，转自https://mangoroom.cn/cpp/call-matplotlib-on-cpp-2.html
C++可视化-Matplot++
最新发布
SmaLLMasteR110的博客
08-23 1909
Matplot++是一个用于数据可视化的图形库，它提供交互式绘图、以高质量格式导出科学出版物绘图的方法、与类似库一致的紧凑语法、数十种具有专用算法的绘图类别、多种编码样式，并支持通用后端。
ubuntu16在C++代码中实现plot函数
wphkadn的博客
03-31 2246
依靠qt的强大第三方库qwt实现plot(不好用来kuan我！！！) 先在qt ide中实现相关功能，然后再将其修改为可以在任意c++程序中运行的代码 需要的第三方库 QT，可以使用命令行或者run文件直接安装 QWT，QWT是专门用于在qt中plot数据的库，适用于 windows与ubuntu。 QWT的安装方法可以依照这篇博客 https://blog.csdn.net/u01345716...
python plot函数参数
06-07
Python中的plot函数通常用于绘制数据的图形。它可以接受以下参数： - x：x轴上的数据点 - y：y轴上的数据点 - linestyle：线条样式 ...这个例子中，我们使用了一个字典参数来设置plot函数的参数值。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值