C++ 中可用的基本类型的事实列表;

发布于 2024-07-14 05:21:55 字数 169 浏览 14 评论 0原文

例如,如果您要编写一个变体类型类,那么您自然需要识别该类的实例所携带的类型。 我想知道是否有人知道人们可能感兴趣的所有原始数据类型的任何官方或半官方(事实上?)参考?

只有基元,不需要像 stringhandle 这样的抽象类型。

谢谢。

If, for example, you're going to write a variant type class, you will naturally need identification of what type an instance of that class is carrying. I'm wondering if anyone knows of any official or semi-official (de-facto?) reference of all primitive datatypes one would possibly be interested in?

Only primitives, and no need for abstract types like string or handle.

Thanks.

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

评论(5

徒留西风 2024-07-21 05:21:55

您是否考虑过让另一个图书馆承担繁重的工作?

Boost.Variant 可能可以满足您的需求,经过充分测试,类型安全且正确,而且非常高效。

或者,如果您想自己推出,请使用 Boost.TypeTraits

Have you considered letting another library do the heavy lifting?

There's Boost.Variant that probably does what you need, fully tested, typesafe and correct, and pretty efficient.

Or if you want to roll your own, use Boost.TypeTraits

弱骨蛰伏 2024-07-21 05:21:55

唯一的官方参考是ISO/IEC 14882 C++标准。

The only official reference is the ISO/IEC 14882 C++ Standard.

兔姬 2024-07-21 05:21:55

谷歌搜索总是一个好的开始。 此处。 现在,提出您的实际问题。

Google Search is always a good start. Here. Now, roll out your actual question.

旧情勿念 2024-07-21 05:21:55

使用任何第三方变体。

您在标准中找不到的所有数据类型。

Use any third-party variant.

All data types you cant find in standard.

执妄 2024-07-21 05:21:55

如果使用 typeid,则不需要了解有关类型的任何信息:

#include <typeinfo>
#include <iostream>

using namespace std;

struct var_base
{
    const type_info & t;
    var_base(const type_info & t) : t(t) {};

    virtual ~var_base() {};
};

template<class T> struct var : var_base
{
    T value;

    var(T x) : var_base(typeid(T)), value(x) {};
};

struct variant {
    const static int max_size=16;

    char data[max_size];
    var_base & v;

    variant() : v(*(var_base*)data) {
        new (data) var<int>(0);
    }

    const type_info & getType() { return v.t; }

    template<class T> T & get() {
        assert(getType()==typeid(T));
        return static_cast< var<T> &>(v).value;
    }

    template<class T> void set(const T & value) {
            // Compile time assert is also possible here.
        assert(sizeof(var<T>)<=max_size);
        v.~var_base();
        new (data) var<T>(value);
    }
};

main()
{
    variant v;
    v.set<float>(1.2);
    cout << v.getType().name() << endl;
    cout << v.get<float>();
    cout << v.get<int>(); // Assert fails
}

请注意,如果您可以接受该值是动态分配的,则可以摆脱 max_size。 我只是想表明,如果您知道最大类型的大小,就地分配也是有效的。

You don't need to know anything about types if you use typeid:

#include <typeinfo>
#include <iostream>

using namespace std;

struct var_base
{
    const type_info & t;
    var_base(const type_info & t) : t(t) {};

    virtual ~var_base() {};
};

template<class T> struct var : var_base
{
    T value;

    var(T x) : var_base(typeid(T)), value(x) {};
};

struct variant {
    const static int max_size=16;

    char data[max_size];
    var_base & v;

    variant() : v(*(var_base*)data) {
        new (data) var<int>(0);
    }

    const type_info & getType() { return v.t; }

    template<class T> T & get() {
        assert(getType()==typeid(T));
        return static_cast< var<T> &>(v).value;
    }

    template<class T> void set(const T & value) {
            // Compile time assert is also possible here.
        assert(sizeof(var<T>)<=max_size);
        v.~var_base();
        new (data) var<T>(value);
    }
};

main()
{
    variant v;
    v.set<float>(1.2);
    cout << v.getType().name() << endl;
    cout << v.get<float>();
    cout << v.get<int>(); // Assert fails
}

Note that you can get rid of max_size, if you can accept that the value is dynamically allocated. I just wanted to show that in place allocation works too, if you know the size of the largest type.

~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文