C++ 实现Variant类

最新推荐文章于 2025-07-12 15:11:18 发布
最新推荐文章于 2025-07-12 15:11:18 发布
阅读量3.6k 收藏 9
点赞数 6
CC 4.0 BY-SA版权
分类专栏： C++应用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WU9797/article/details/96768653

Variant类借鉴于Qt的QVariant类，类似于Boost的any类。它把常用类型使用一个类包装起来，这样使用QVector等容器时，其内部就可以存储不同的数据。例如：

std::vector<Variant> vec;
vec.push_back(1);        // 整形
vec.push_back("str");    // 字符串
vec.push_back(false);    // bool变量
vec.push_back(1.2);      // 浮点数

当然，没有做到像QVariant类那么全面，现阶段仅仅提供了基本数据类型和std::string、std::wstring、char *, wchar_t *类型的数据封装。后续若有完善，再另行给出源码，目前版本仅仅为大家提供一个参考，与大家共同学习与交流。话不多说，上源码：

（编译器：VS2017 msvc15）

/**
 * \filename    Variant.h
 * \breif        The header file of class Variant.
 * \date        2019-07-21
 * \author        shaoguang
 */

#ifndef VARIANT_H
#define VARIANT_H

#include <string>

class Variant
{
public:
    using uchar = unsigned char;
    using ushort = unsigned short;
    using uint = unsigned int;
    using ulong = unsigned long;
    using ulonglong = unsigned long long;
    using wchar = wchar_t;
public:
    enum Type {
        Invalid,
        Bool,
        Char,
        UChar,
        Short,
        UShort,
        Int,
        UInt,
        Long,
        ULong,
        LongLong,
        ULongLong,
        Float,
        Double,
        LongDouble,
        WChar,

        String,            // std::string
        WString,        // std::wstring
    };

    template<typename T>
    static Type typeID();
public:
    Variant();
    ~Variant();

    Variant(bool b);
    Variant(char c);
    Variant(uchar uc);
    Variant(wchar_t wc);
    Variant(short s);
    Variant(ushort us);
    Variant(int i);
    Variant(uint ui);
    Variant(long l);
    Variant(ulong ul);
    Variant(long long ll);
    Variant(ulonglong ull);
    Variant(float f);
    Variant(double d);
    Variant(long double ld);
    Variant(const char *str);
    Variant(const wchar_t *wstr);
    Variant(const std::string &str);
    Variant(const std::wstring &wstr);

    Variant(const Variant &other);
    Variant(Variant &&other);
    Variant &operator=(const Variant &other);
    Variant &operator=(Variant &&other);

    Type type() const;
    bool canConvert(Type type) const;
    bool isValid() const;

    bool toBool() const;
    char toChar() const;
    uchar toUchar() const;
    wchar toWChar() const;
    short toShort() const;
    ushort toUShort() const;
    int toInt() const;
    uint toUInt() const;
    long toLong() const;
    ulong toULong() const;
    long long toLongLong() const;
    ulonglong toULongLong() const;
    float toFloat() const;
    double toDouble() const;
    long double toLongDouble() const;
    std::string toString() const;
    std::wstring toWString() const;


private:
    void make_invalid();

    template<typename T>
    static T strToNumber(const std::string &str);
    template<typename T>
    static T strToNumber(const std::wstring &wstr);

    template<typename T>
    T numVariantToHelper(const T &val) const;

    template <typename T>
    static inline void safe_delete_void_ptr(void *&target);

private:
    struct Private {
        inline Private() noexcept : type(Invalid), is_shared(false), is_null(true)
        {
            data.ptr = nullptr;
        }

        // Internal constructor for initializing variant.
        explicit inline Private(Type variantType) noexcept
            : type(variantType), is_shared(false), is_null(false)
        {}

        inline Private(const Private &other) noexcept
            : data(other.data), type(other.type),
            is_shared(other.is_shared), is_null(other.is_null)
        {}

        union Data {
            bool b;
            char c;
            uchar uc;
            wchar_t wc;
            short s;
            ushort us;
            int i;
            uint ui;
            long l;
            ulong ul;
            long long ll;
            ulonglong ull;
            float f;
            double d;
            long double ld;
            void *ptr;
        }data;

        Type type;
        bool is_shared;
        bool is_null;
    };
    Private        _d;
};

#endif    // VARIANT_H

 

#include "Variant.h"

#include <sstream>

Variant::Variant()
    : _d(Invalid)
{
}

Variant::~Variant()
{
    if (String == _d.type)
    {
        if (_d.data.ptr)
            safe_delete_void_ptr<char *>(_d.data.ptr);
    }
    else if (WString == _d.type)
    {
        if (_d.data.ptr)
            safe_delete_void_ptr<wchar_t *>(_d.data.ptr);
    }
}

Variant::Variant(bool b)
    : _d(Bool)
{
    _d.data.b = b;
}

Variant::Variant(char c)
    : _d(Char)
{
    _d.data.c = c;
}

Variant::Variant(uchar uc)
    : _d(UChar)
{
    _d.data.uc = uc;
}

Variant::Variant(wchar_t wc)
    : _d(WChar)
{
    _d.data.wc = wc;
}

Variant::Variant(short s)
    : _d(Short)
{
    _d.data.s = s;
}
Variant::Variant(ushort us)
    : _d(UShort)
{
    _d.data.us = us;
}
Variant::Variant(int i)
    : _d(Int)
{
    _d.data.i = i;
}
Variant::Variant(uint ui)
    : _d(UInt)
{
    _d.data.ui = ui;
}
Variant::Variant(long l)
    : _d(Long)
{
    _d.data.l = l;
}
Variant::Variant(ulong ul)
    : _d(ULong)
{
    _d.data.ul = ul;
}
Variant::Variant(long long ll)
    : _d(LongLong)
{
    _d.data.ll = ll;
}
Variant::Variant(ulonglong ull)
    : _d(ULongLong)
{
    _d.data.ull = ull;
}
Variant::Variant(float f)
    : _d(Float)
{
    _d.data.f = f;
}
Variant::Variant(double d)
    : _d(Double)
{
    _d.data.d = d;
}
Variant::Variant(long double ld)
    : _d(LongDouble)
{
    _d.data.ld = ld;
}

Variant::Variant(const char *str)
    : _d(String)
{
    if (!str) {
        make_invalid();
    } else {
        size_t len = strlen(str);
        _d.data.ptr = new char[strlen(str) + 1];
        strcpy_s(static_cast<char *>(_d.data.ptr), strlen(str) + 1, str);
    }
}

Variant::Variant(const wchar_t * wstr)
{
    if (!wstr) {
        make_invalid();
    } else {
        _d.data.ptr = new char[wcslen(wstr) + 1];
        wcscpy_s((wchar_t *)_d.data.ptr, wcslen(wstr) + 1, wstr);
    }
}

Variant::Variant(const std::string &str)
    : _d(String)
{
    if (str.empty()) {
        make_invalid();
    } else {
        _d.data.ptr = new char[str.size() + 1];
        strcpy_s((char *)_d.data.ptr, str.size() + 1, str.c_str());
    }
}

Variant::Variant(const std::wstring &wstr)
    : _d(WString)
{
    if (wstr.empty()) {
        make_invalid();
    } else {
        _d.data.ptr = new wchar_t[wstr.size() + 1];
        wcscpy_s((wchar_t *)_d.data.ptr, wstr.size() + 1, wstr.c_str());
    }
}

Variant::Variant(const Variant &other)
    : _d(other._d)
{
    if (String == _d.type)
    {
        _d.data.ptr = new char[strlen(static_cast<char *>(other._d.data.ptr)) + 1];
        strcpy_s(static_cast<char *>(_d.data.ptr), strlen(static_cast<char *>(other._d.data.ptr)) + 1,
            static_cast<char *>(other._d.data.ptr));
    }
    else if (WString == _d.type)
    {
        _d.data.ptr = new char[wcslen(static_cast<wchar_t *>(other._d.data.ptr)) + 1];
        wcscpy_s(static_cast<wchar_t *>(_d.data.ptr), wcslen(static_cast<wchar_t *>(other._d.data.ptr)) + 1,
            static_cast<wchar_t *>(other._d.data.ptr));
    }
}
Variant::Variant(Variant &&other)
    : _d(other._d)
{
    if (String == other._d.type || WString == other._d.type)
    {
        this->_d.data.ptr = other._d.data.ptr;
        other.make_invalid();
    }
}

Variant &Variant::operator=(const Variant &other)
{
    if (this == &other)
        return *this;
    if (String == _d.type || WString == _d.type)
    {
        if (_d.data.ptr)
        {
            delete []_d.data.ptr;
            _d.data.ptr = nullptr;
        }
    }
    if (Invalid == other._d.type)
    {
        make_invalid();
        return *this;
    }
    else if (String == other._d.type)
    {
        _d.data.ptr = new char[strlen(static_cast<char *>(other._d.data.ptr)) + 1];
        strcpy_s(static_cast<char *>(_d.data.ptr), strlen(static_cast<char *>(other._d.data.ptr)) + 1,
            static_cast<char *>(other._d.data.ptr));
    }
    else if (WString == other._d.type)
    {
        _d.data.ptr = new char[wcslen(static_cast<wchar_t *>(other._d.data.ptr)) + 1];
        wcscpy_s(static_cast<wchar_t *>(_d.data.ptr), wcslen(static_cast<wchar_t *>(other._d.data.ptr)) + 1,
            static_cast<wchar_t *>(other._d.data.ptr));
    }
    else
        _d.data = other._d.data;
    this->_d.type = other._d.type;
    this->_d.is_null = other._d.is_null;
    this->_d.is_shared = other._d.is_shared;
    return *this;
}
Variant &Variant::operator=(Variant &&other)
{
    if (this == &other)
        return *this;
    this->_d = other._d;
    if (String == _d.type || WString == _d.type)
    {
        this->_d.data.ptr = other._d.data.ptr;
        other.make_invalid();
    }
    return *this;
}

Variant::Type Variant::type() const
{
    return _d.type;
}

bool Variant::canConvert(Type type) const
{
    if (Invalid == type)
        return false;
    switch (_d.type)
    {
    case Invalid:        return false;
    case Char:            return WChar != type && WString != type;
    case UChar:            return WChar != type && WString != type;
    case WChar:            return Char != type && String != type;
    case Short:            return true;
    case UShort:        return true;
    case Int:            return true;
    case UInt:            return true;
    case Long:            return true;
    case ULong:            return true;
    case LongLong:        return true;
    case ULongLong:        return true;
    case Float:            return Char != type && UChar != type && WChar != type;
    case Double:        return Char != type && UChar != type && WChar != type;
    case LongDouble:    return Char != type && UChar != type && WChar != type;
    case String:        return WString != type;
    case WString:        return String != type;
    default: break;
    }
    return false;
}

bool Variant::isValid() const
{
    return _d.type != Invalid;
}

std::string Variant::toString() const
{
    if (!isValid() || WString == _d.type)
        return "";
    if (String == _d.type)
        return static_cast<char *>(_d.data.ptr);

    std::stringstream ss;
    try {
        switch (_d.type)
        {
        case Bool:
            if (_d.data.b) ss << "true";
            else ss << "false"; break;
        case Char:            ss << _d.data.c;    break;
        case UChar:            ss << _d.data.uc;    break;
        case WChar:                                break;
        case Short:            ss << _d.data.s;    break;
        case UShort:        ss << _d.data.us;    break;
        case Int:            ss << _d.data.i;    break;
        case UInt:            ss << _d.data.ui;    break;
        case Long:            ss << _d.data.l;    break;
        case ULong:            ss << _d.data.ul;    break;
        case LongLong:        ss << _d.data.ll;    break;
        case ULongLong:        ss << _d.data.ull;    break;
        case Float:            ss << _d.data.f;    break;
        case Double:        ss << _d.data.d;    break;
        case LongDouble:    ss << _d.data.ld;    break;
        default: break;
        }
    } catch (...) {
        return ss.str();
    }

    return ss.str();
}

std::wstring Variant::toWString() const
{
    if (!isValid() || String == _d.type)
        return L"";
    if (WString == _d.type)
        return static_cast<wchar_t *>(_d.data.ptr);

    std::wstringstream wss;
    try {
        switch (_d.type)
        {
        case Bool:
            if (_d.data.b) wss << L"true";
            else wss << L"false"; break;
        case Char:            wss << _d.data.c;    break;
        case UChar:            wss << _d.data.uc;    break;
        case WChar:            wss << _d.data.wc;    break;
        case Short:            wss << _d.data.s;    break;
        case UShort:        wss << _d.data.us;    break;
        case Int:            wss << _d.data.i;    break;
        case UInt:            wss << _d.data.ui;    break;
        case Long:            wss << _d.data.l;    break;
        case ULong:            wss << _d.data.ul;    break;
        case LongLong:        wss << _d.data.ll;    break;
        case ULongLong:        wss << _d.data.ull;    break;
        case Float:            wss << _d.data.f;    break;
        case Double:        wss << _d.data.d;    break;
        case LongDouble:    wss << _d.data.ld;    break;
        default: break;
        }
    } catch (...) {
        return wss.str();
    }

    return wss.str();
}
bool Variant::toBool() const
{
    switch (_d.type)
    {
    case Bool:    return _d.data.b;
    case String: return (strcmp((char *)_d.data.ptr, "true") == 0);
    case WString: return (wcscmp((wchar_t *)_d.data.ptr, L"true") == 0);
    default: return numVariantToHelper<bool>(_d.data.b);
    }
}
char Variant::toChar() const
{
    return numVariantToHelper<char>(_d.data.c);
}
Variant::uchar Variant::toUchar() const
{
    return numVariantToHelper<uchar>(_d.data.uc);
}
wchar_t Variant::toWChar() const
{
    return numVariantToHelper<wchar_t>(_d.data.wc);
}
short Variant::toShort() const
{
    return numVariantToHelper<short>(_d.data.s);
}
Variant::ushort Variant::toUShort() const
{
    return numVariantToHelper<ushort>(_d.data.us);
}
int Variant::toInt() const
{
    return numVariantToHelper<int>(_d.data.i);
}
Variant::uint Variant::toUInt() const
{
    return numVariantToHelper<uint>(_d.data.ui);
}
long Variant::toLong() const
{
    return numVariantToHelper<long>(_d.data.l);
}
Variant::ulong Variant::toULong() const
{
    return numVariantToHelper<ulong>(_d.data.ul);
}
long long Variant::toLongLong() const
{
    return numVariantToHelper<long long>(_d.data.ll);
}
Variant::ulonglong Variant::toULongLong() const
{
    return numVariantToHelper<ulonglong>(_d.data.ull);
}
float Variant::toFloat() const
{
    return numVariantToHelper<float>(_d.data.f);
}
double Variant::toDouble() const
{
    return numVariantToHelper<double>(_d.data.d);
}
long double Variant::toLongDouble() const
{
    return numVariantToHelper<long double>(_d.data.ld);
}

void Variant::make_invalid()
{
    _d.type = Invalid;
    _d.is_null = true;
    _d.is_shared = false;
    _d.data.ptr = nullptr;
}

template<typename T>
Variant::Type Variant::typeID()
{
    if (std::is_same_v<T, bool>)
        return Bool;
    if (std::is_same_v<T, char>)
        return Char;
    if (std::is_same_v<T, uchar>)
        return UChar;
    if (std::is_same_v<T, wchar_t>)
        return WChar;
    if (std::is_same_v<T, short>)
        return Short;
    if (std::is_same_v<T, ushort>)
        return UShort;
    if (std::is_same_v<T, int>)
        return Int;
    if (std::is_same_v<T, uint>)
        return UInt;
    if (std::is_same_v<T, long>)
        return Long;
    if (std::is_same_v<T, ulong>)
        return ULong;
    if (std::is_same_v<T, long long>)
        return LongLong;
    if (std::is_same_v<T, ulonglong>)
        return ULongLong;
    if (std::is_same_v<T, float>)
        return Float;
    if (std::is_same_v<T, double>)
        return Double;
    if (std::is_same_v<T, long double>)
        return LongDouble;
    if (std::is_same_v<T, std::string>)
        return String;
    if (std::is_same_v<T, std::wstring>)
        return WString;

    return Invalid;
}

template<typename T>
T Variant::strToNumber(const std::string &str)
{
    try {
        switch (typeID<T>())
        {
        case Bool:            return stoi(str);        break;
        case Char:            return stoi(str);        break;
        case UChar:            return stoul(str);        break;
        case WChar:            return stoi(str);        break;
        case Short:            return stoi(str);        break;
        case UShort:        return stoul(str);        break;
        case Int:            return stoi(str);        break;
        case UInt:            return stoul(str);        break;
        case Long:            return stol(str);        break;
        case ULong:            return stoul(str);        break;
        case LongLong:        return stoll(str);        break;
        case ULongLong:        return stoull(str);;    break;
        case Float:            return stof(str);        break;
        case Double:        return stod(str);        break;
        case LongDouble:    return stold(str);        break;
        default: break;
        }
    } catch (...) {
        return T();
    }

    return T();
}

template<typename T>
T Variant::strToNumber(const std::wstring &wstr)
{
    try {
        switch (typeID<T>())
        {
        case Bool:            return stoi(wstr);        break;
        case Char:            return stoi(wstr);        break;
        case UChar:            return stoul(wstr);        break;
        case WChar:            return stoi(wstr);        break;
        case Short:            return stoi(wstr);        break;
        case UShort:        return stoul(wstr);        break;
        case Int:            return stoi(wstr);        break;
        case UInt:            return stoul(wstr);        break;
        case Long:            return stol(wstr);        break;
        case ULong:            return stoul(wstr);        break;
        case LongLong:        return stoll(wstr);        break;
        case ULongLong:        return stoull(wstr);;    break;
        case Float:            return stof(wstr);        break;
        case Double:        return stod(wstr);        break;
        case LongDouble:    return stold(wstr);        break;
        default: break;
        }
    } catch (const std::exception&) {
        return T();
    }

    return T();
}

template<typename T>
T Variant::numVariantToHelper(const T &val) const
{
    if (typeID<T>() == _d.type)
        return val;

    switch (_d.type)
    {
    case Bool:            return T(_d.data.b);    break;
    case Char:            return T(_d.data.c);    break;
    case UChar:            return T(_d.data.uc);    break;
    case WChar:            return T(_d.data.wc);    break;
    case Short:            return T(_d.data.s);    break;
    case UShort:        return T(_d.data.us);    break;
    case Int:            return T(_d.data.i);    break;
    case UInt:            return T(_d.data.ui);    break;
    case Long:            return T(_d.data.l);    break;
    case ULong:            return T(_d.data.ui);    break;
    case LongLong:        return T(_d.data.ll);    break;
    case ULongLong:        return T(_d.data.ull);;    break;
    case Float:            return T(_d.data.f);    break;
    case Double:        return T(_d.data.d);    break;
    case LongDouble:    return T(_d.data.ld);    break;
    case String:        return strToNumber<T>(static_cast<char *>(_d.data.ptr));
    case WString:        return strToNumber<T>(static_cast<wchar_t *>(_d.data.ptr));
    default: break;
    }
    return T();
}

template<typename T>
inline void Variant::safe_delete_void_ptr(void *&target)
{
    if (target)
    {
        T temp = static_cast<T>(target);
        delete []temp;
        temp = nullptr;
        target = nullptr;
    }
}

 

 

 下面写一个简单的测试程序：

#include <iostream>
#include <stdlib.h>
using namespace std;

#include "Variant.h"
#include <vector>

int main(int argc, char *argv[])
{
    std::vector<Variant> vec;
    vec = {true, 'c', 1, 1.2, "shaoguang"};

    for (auto &v : vec)
        std::cout << v.toString() << std::endl;

    system("pause");
    return 0;
}

输出结果：

C++(17)：variant
风静如云的博客
11-27 3957
2.variant构造时，如果没有指明类型，会用第一个类型（索引为0的类型）的默认构造函数进行构造（如上例中对象d），因此第一个类型必须具有默认构造函数。如果变体类型 v 存放的数据类型下标为 Index，那么返回所存放数据的指针，否则返回空指针。如果变体类型 v 存放的数据类型下标为 Index，那么返回所存放的数据，否则抛出异常。如果变体类型 v 存放的数据类型为 T，那么返回所存放数据的指针，否则返回空指针。如果变体类型 v 存放的数据类型为 T，那么返回所存放的数据，否则抛出异常。
C++编程新技能！std::variant详解，掌握多类型值存储！
Lion_Long的博客
03-23 1万+
C++标准库中的std::variant是C++17引入的一种数据类型，它的作用是可以同时存储多种不同类型的值，但在任意时间只能有一种类型的值被存储。这使得std::variant成为一种灵活的数据类型，适用于需要处理多种可能类型的情况。std::variant的优势在于它提供了类型安全和便利的接口，相比传统的联合体（union），std::variant不需要手动管理数据成员的活跃性，也提供了更加友好和安全的访问方法。它在处理多样化数据类型、泛型编程以及处理变化的数据结构时非常有用。
C++变体数据类型—— VARIANT
热门推荐
Play up! 程序人生 ZQC
10-20 1万+
百度百科：Variant　　音标 Phonetic symbol 　　[]　词性及解释 Part of speech and defination 　　n. 变体, 异体　　a. 不同的, 有差别的　　【计】 变体型　　【化】 变体　　【医】 变异的; 变异体, 变型, 变种　　Variant 数据类型是所有没被显式声明（用如 Dim、Private、Public 或 Static等语句）
C++ 可变体(variant)
weixin_45925735的博客
03-22 6633
那么给他ItCat这个用户自定义类型加一个默认构造器，那么在可变体在初始化过程中，就能从类型参数列表<ItCat,int, float>中的第一个ItCat获得一个默认构造器。下面的代码是声明一个可变体的用法，在variant关键字的尖括号内，依次指定可变体的的数据类型。传递给，std::visit回调的函数，而这回调函数就是所谓的“访问者”，以实现一些非常复杂的业务逻辑。的C++编译器来说，无疑是给它增加困扰，而C++编译器对待这种模棱两可的值，它默认匹配值的数据类型是。的情况下，会得到一个编译器错误。
C++17 std::variant 详解
最新发布
weixin_64612849的博客
07-12 582
是 C++17 中一个强大的特性，它提供了类型安全的联合体功能。通过合理使用避免使用不安全的union创建更加类型安全的代码简化错误处理逻辑提高代码的可读性和可维护性。
C++ variant (tcy)
tcy-阿春
01-14 4202
1.1.用途： 用于存储和操作不同类型对象,是一个类型安全的联合体(union). variant实例存储某一类型的数据,可指定重复的数据类型. 1.2.注意：variant的指定类型不能是引用类型,数组类型以及void类型, 1.3.说明：默认以首个指定类型进行初始化,首个类型必须支持默认构造函数 1.4.variant<> 操作 constructors //构造函数-创建variant对象(调用底层类型构造函数) = .
variant:Variant 是一个变化的 C++11 类，它尽可能地克隆 javascript 行为
06-07
标题提到的"variant:Variant 是一个变化的 C++11 类"可能是指某个库或自定义实现，尝试在C++11标准下模拟这种行为。 `variant`的主要作用是处理异构数据，即在不同的时间点，同一变量可以持有不同类型的数据。这在...
Modern C++ std::variant的实现原理
深山老宅的虚拟空间
02-22 4205
std::variant的实现原理
Variant.zip_c++变体实现_variant cpp
07-14
C++ 变体类实现类及资料包含source code
使用C++ 17 variant and visit实现 Multiple Dispatch
weixin_42244181的博客
08-26 860
get_objects(): 假定这个函数返回一个 std::vector，其中包含若干 std::variant 对象，即飞船或小行星的列表。std::visit: 通过传入的两个 std::variant（obj 和 other），std::visit 会自动匹配其中包含的类型，并将其传递给 lambda 函数。对于每对 obj 和 other，使用 std::visit 来处理它们的类型并调用适当的 lambda 函数。= default;
Modern C++ std::variant的6个特性+原理
深山老宅的虚拟空间
02-22 4021
variant 5个特性+实现原理
C++17尝鲜：variant
zwvista的专栏
07-24 1万+
variant variant 是 C++17 所提供的变体类型。variant&lt;X, Y, Z&gt; 是可存放 X, Y, Z 这三种类型数据的变体类型。 与C语言中传统的 union 类型相同的是，variant 也是联合(union)类型。即 variant 可以存放多种类型的数据，但任何时刻最多只能存放其中一种类型的数据。 与C语言中传统的 union 类型所不同的是，var...
C++中的variant和any
m0_49844997的博客
04-21 438
【代码】C++中的variant和any。
C++ VARIANT 学习小记录
weixin_34413802的博客
07-24 219
一：为什么会有这个？ 　　目前，计算机语言有很多（大哥，为什么不能就那么一样呢？），如C++、Java，此外还有JavaScript、VBScript等脚本语言，它们自立门派，各自维护自己的数据类型。 　　C++是一种强类型语言，即C++中的某个变量，在使用时类型已经确定，C++中的变量都会被翻译成准确的内存地址和大小，如果类型不确定是不可能处理的。当使用C++这样强类型的语言来读取...
C++ std::variant 总结
PX1525813502的博客
04-26 1949
return 0;输出如下:1010.3Aborted写入浮点数后再访问整数类型成员, 直接抛出了异常, 这提供了一个类型安全的保证。除此之外, 它能自动维护C++ 当中的复杂类型,也就是构造和析构函数的调用。return 0;1010.3。
variant (C++ 模板元编程)
lifehappy
11-04 661
std::variant 可以理解为一个会自动清除空间的union，保证了赋值时内存的正确性，能够自动进行析构。 通过get可传入下标或者type来获取值，但是不安全，如果传入类型于当前类型不一致时会引发错误。 可以通过get_if传入下标或者值和variant指针来安全获得值。 有类模板variant_alternative来获取第几个属性的type，以及类模板variant_size来获取variant中存放了多少个属性。 variant get< type > get< N &gt
【现代C++学习】variant 总结
changhen123的博客
08-28 1729
访问者模式：实现一个甚至多个可变体对象以引用的方式传递给。访问者：一个接受来自每个变体的回调函数。
【C++ std::variant】深入探索 C++ std::variant：构造方法与实践应用
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
01-09 1480
`std::variant`，或称标准变体，是 C++17 标准库引入的一种类型，用于安全地存储并访问多种类型中的一种。此特性在编程中的引入，反映了人们对灵活性和效率的追求，这正符合心理学中对人类追求效率和适应性的观点。
c++ 实现Variant，并可以拷贝操作
06-10
在 C++ 中可以使用模板实现 Variant ，具体实现如下： ```cpp #include #include class Variant { public: Variant() noexcept = default; Variant(const Variant& other) { if (other._data) { other._...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值