跟我学c++高级篇——动态反射之一遍历

最新推荐文章于 2023-12-03 12:49:08 发布

fpcc

最新推荐文章于 2023-12-03 12:49:08 发布

阅读量310

点赞数 1

分类专栏： C++11 C++ 文章标签： c++

本文链接：https://blog.csdn.net/fpcc/article/details/134756134

版权

C++ 同时被 2 个专栏收录

229 篇文章 32 订阅

订阅专栏

C++11

224 篇文章 93 订阅

订阅专栏

一、动态反射

前面讲一篇静态反射，今天在这个基础上对动态反射进行一下入门。动态反射前面提到过，一般是指在运行时动态获取类型或者生成实例。那么如何才能动态获得类型呢？方法有很多种，下面从最简单的开始。

二、入门程序

动态反射的一个简单例子如下：

#include <tuple>
#include <string>
#include <unordered_map>
#include <iostream>

enum class RgbColor {RGB_RED,RGB_BLACK,RGB_WHITE,NOTHING};

std::tuple<std::string, std::string, std::string> tDesc = {"red","black","white"};
std::unordered_map<std::string, RgbColor> mapColor = { {"red",RgbColor::RGB_RED},{"black",RgbColor::RGB_BLACK},{"white",RgbColor::RGB_WHITE}};

RgbColor strToType(const std::string& color)
{
	auto num = mapColor.count(color);
	if (num > 0) {
		return mapColor[color];
	}
	else {
		return RgbColor::NOTHING;
	}
}

void GetColorTest(const std::string&str)
{
	auto color = strToType(str);
	std::cout << "str is:" << str << "," << "Color is:" << static_cast<int>(color) << std::endl;
}

但是这么做除了麻烦外还容易出错。另外为了一个简单的反射，写了如此多的不可重用的代码确实也让人觉得有点低效。

三、使用__PRETTY_FUNCTION__

其实动态反射的核心在动态类型的获取，那么可以在前面使用__PRETTY_FUNCTION__的基础上对其进行处理，从而使其可以在运行获取对象的类型：

#include <iostream>
#include <string>

#ifdef _WIN64
#define __FUNC__ __FUNCSIG__
#else
#define __FUNC__  __PRETTY_FUNCTION__
#endif

enum class DataType{USB,PCI,HD};
enum  DType{USB,PCI,HD};
template<auto T>
auto TypeInfo()
{
    std::string type = __FUNC__;
    auto s = type.find("T = ") + 4;
    auto e = type.find_last_of(']');
    return std::string_view{ type.data() + s, e - s };
}

template<typename T>
std::string_view Typeof(T t)
{
   int t1 = static_cast<int>(t);
    if (t1 == 0)
    {
        return TypeInfo<DataType::USB>();
    }

    if (t1 == 1)
    {
        return TypeInfo<DataType::PCI>();
    }
    if (t1 == 2)
    {
        return TypeInfo<DataType::HD>();
    }
    return std::string_view("");
}

void getTypeTest()
{
    std::cout << Typeof(DataType::HD) << std::endl;
    std::cout << Typeof<DType>(DType::PCI) << std::endl;
}

int main()
{
    getTypeTest();
    return 0;
}

上面这些代码其实和最初的代码不同点在于他可以动态的适应名称的变化和相关内容的增加而不需要增加代码的编写和维护。可是上面的代码还是有些麻烦，比如枚举的值不断的增加，那么if语句就这么一直增加下去么？可行是可行的，但有点不爽，可以写成下面的形式：

#include <iostream>
#include <string>
#include <type_traits>

#ifdef _WIN64
#define __FUNC__ __FUNCSIG__
#else
#define __FUNC__  __PRETTY_FUNCTION__
#endif

enum class DataType{USB,PCI,HD,NOT};
enum  DType{USB,PCI,HD,NOT};
template<auto T>
 auto TypeInfo()
{
    std::string type = __FUNC__;
    auto begin = type.find("T = ") + 4;
    auto end = type.find_last_of(']');
    return std::string_view{ type.data() + begin, end - begin };
}

template <int s, int e>
struct static_for
{
    template<typename F>
    void operator()(const F& func) const
    {
        if (s < e)
        {
            //注意：一定要转成常量
            func(std::integral_constant<int,s>());
            static_for<s + 1, e>()(func);
        }
    }
};

template <int n>
struct static_for<n, n>
{
    template<typename F>
    void operator()( const F & func) const
    {
       // std::cout << "noting" << std::endl;
    }
};
constexpr int s = static_cast<int>(DataType::USB);
constexpr int e = static_cast<int>(DataType::NOT);

template<typename T>
std::string_view Typeof(T t)
{
   int t1 = static_cast<int>(t);
   std::string_view sv;
       static_for<s, e>()([&](auto num) {
        if (t1 == num) {
             //重点要理解const和num.value
             const DataType d = DataType{num.value};
            sv = TypeInfo<d>();
            }
            });

    return sv;
}

void getTypeTest()
{
    std::cout << Typeof(DataType::HD) << std::endl;
    //std::cout << Typeof<DType>(DType::PCI) << std::endl;
}

int main()
{
        getTypeTest();
        return 0;
}