访问成员变量时添加const

时间:2015-06-29 12:40:25

标签: c++ c++11 const

我需要一个围绕数据结构的透明包装来添加一些属性。 最简单的是这样的:

template<typename T>
struct Wrapper{
    T values;
}

现在我想将它传递给一个访问器并保持constness。基数将是:

template<class T>
T& accVal(usigned idx, T* vals){ return vals[idx]; }
template<class T>
const T& accVal(usigned idx, const T* vals){ return vals[idx]; }

template<class T>
auto
acc(unsigned idx, T& data) -> decltype(accVal(idx, data.values))
{
    return accVal(idx, data.values);
}

//Example:
Wrapper<int*> intsWrapped;
cout << acc(1, intsWrapped);

这仅适用于非指针,比如将“T *”替换为结构,因为对data.values的访问会丢弃数据的常量,我可以像以下一样操作它:

void foo(const Wrapper<int*>& bar){ acc(1, bar) = 5; }

这在我的申请中很危险。

那么我怎样才能保留常量呢?我试过这样的事情:

template< class T_Base, typename T_Mem >
struct GetConstCorrect
{
    template< typename T >
    struct AddConstVal: std::add_const<T>{};

    template< typename T >
    struct AddConstVal<T&>
    {
        using type = std::add_const_t<T> &;
    };

    template< typename T >
    struct AddConstVal<T*>
    {
        using type = std::add_const_t<T>*;
    };

    template< typename T >
    struct AddConstVal<T* const>
    {
        using type = std::add_const_t<T>* const;
    };

    template< typename T >
    struct AddConstVal<T*&>
    {
        using type = std::add_const_t<T>*&;
    };

    template< typename T >
    struct AddConstVal<T*const &>
    {
        using type = std::add_const_t<T>* const &;
    };

    using Base = T_Base;
    using Mem = T_Mem;

    static constexpr bool isConst = std::is_const<Base>::value;
    using type = std::conditional_t< isConst,
            typename AddConstVal<Mem>::type,
            Mem
            >;
};

template< class T_Base, typename T_Mem >
using GetConstCorrect_t = typename GetConstCorrect< T_Base, T_Mem >::type;

template< class T_Base, typename T_Mem >
GetConstCorrect_t< T_Base, T_Mem& >
getConstCorrect(T_Mem& mem)
{
    return const_cast<GetConstCorrect_t< T_Base, T_Mem& >>(mem);
}

并通过getConstCorrect(data.values)访问data.values,但这似乎仍然容易出错。 (例如,像int **这样的多指针将成为int const 而不是int const **)

有没有更好的方法来实现这一目标?

1 个答案:

答案 0 :(得分:2)

在任何人提出更好的解决方案之前,我认为这是一个答案: 使用AddConstVal作为递归元函数,逐个删除所有修饰符,调用自身并读取修饰符。

template< typename T >
struct AddConstVal: std::add_const<T>{};

template< typename T >
using AddConstVal_t = typename AddConstVal<T>::type;

template< typename T >
struct AddConstVal<T&>
{
    using type = AddConstVal_t<T>&;
};

template< typename T >
struct AddConstVal<T*>
{
    using type = AddConstVal_t<T>*;
};

template< typename T >
struct AddConstVal<T const>
{
    using type = AddConstVal_t<T> const;
};

template< typename T >
struct AddConstVal<T volatile>
{
    using type = AddConstVal_t<T> volatile;
};

template< typename T >
struct AddConstVal<T []>
{
    using type = AddConstVal_t<T> [];
};

template< typename T, size_t N >
struct AddConstVal<T [N]>
{
    using type = AddConstVal_t<T> [N];
};