C++类型铸造指向常量变量的指针

问题描述：

我希望有一种方法可以为具有大量可访问（但不可编辑）数据成员的类的单个get函数编写混合类型。如下面的代码所示，使用一个包含成员地址的void * -cast副本的地图是可行的，但只要将'const'引入到混合中以强制执行只读，C++就会说： 'const void *'类型不能重写以适当地访问数据成员。下面的代码适用于为一类混合数据类型编写单个get函数，但它有效地使get函数访问所有数据成员为public（具体请参阅memlist类中的get函数）。C++类型铸造指向常量变量的指针

底线：

有没有一种方法，使指针型浇注料，同时保留只读在实际内存位置？或者更根本的是，是否可以定义一个类型强制转换为常量变量的指针？例如，在我看来，const type *var为只读变量定义了一个只读/不可转换的地址，而我试图找到一些东西（迄今为止还不适用于我），更像type * const var，尽管我一直没有找到任何有关这方面的文件。

#include <iostream> 
#include <string> 
#include <map> 

class A{ 
public: 
    A(int a, double b): a(a), b(b) {}; 
private: 
    int a; 
    double b; 

    friend std::ostream& operator<<(std::ostream& os, A& rhs); 
}; 

class memlist{ 
public: 
    memlist(int param1, double param2) 
    { 
     myint = new int(param1); 
     mydouble = new double(param2); 
     myclass = new A(param1,param2); 

     getMap["myint"] = myint; 
     getMap["mydouble"] = mydouble; 
     getMap["myclass"] = myclass; 
    } 
    ~memlist() 
    { 
     delete myint; 
     delete mydouble; 
     delete myclass; 
    } 
    void* get(std::string param) {return getMap[param];}; 
private: 
    int *myint; 
    double *mydouble; 
    A *myclass; 

    std::map<std::string,void*> getMap; 
}; 

std::ostream& operator<<(std::ostream& os, A& rhs){ 
    os << rhs.a << std::endl << rhs.b; 
    return os; 
}; 

int main(){ 
    int myint = 5; 
    double mydbl = 3.14159263; 
    memlist mymem(myint,mydbl); 

    std::cout << *(int*)mymem.get("myint") << std::endl; 
    std::cout << *(double*)mymem.get("mydouble") << std::endl; 
    std::cout << *(A*)mymem.get("myclass") << std::endl; 
    *(int*)mymem.get("myint") = 10; 
    std::cout << *(int*)mymem.get("myint") << std::endl; 

    return 0; 
}

输出：

对于必须维护此代码的程序员，我感到很遗憾。对于像这样的事情，C++有'std :: any'。 – PaulMcKenzie

[std :: any usage]（http://coliru.stacked-crooked.com/a/af4a1032226f6d60） – PaulMcKenzie

@PaulMcKenzie谢天谢地，这只是我玩指针而已... – charlestoncrabb

答

所示的代码是非常，应当说，设计不良。

void*与C++中的类型系统差不多。如评论中所述，std::any是更好的解决方案。

也就是说，我认为这是一个挑战，以类型安全的方式实现您在问题中所阐述的内容。至少可以说这太过分了。

#include <iostream> 
#include <type_traits> 

using namespace std; 

template<typename> 
struct is_str_literal : false_type {}; 

template<size_t N> 
struct is_str_literal<const char[N]> : true_type {}; 

template<typename T> 
struct is_str_literal<T&> : is_str_literal<T> {}; 

template<typename T> 
constexpr bool is_str_literal_v = is_str_literal<T>::value; 

constexpr bool samestr(const char* arr1, const char* arr2, size_t n) 
{ 
    return n == 0 ? arr1[0] == arr2[0] : 
        (arr1[n] == arr2[n]) && samestr(arr1, arr2, n - 1); 
} 

template<size_t N1, size_t N2> 
constexpr bool samestr(const char (&arr1)[N1], const char (&arr2)[N2]) 
{ 
    return N1 == N2 ? samestr(arr1, arr2, N1 - 1) : false; 
} 

constexpr char myint[] = "myint"; 
constexpr char mydouble[] = "mydouble"; 
constexpr char myclass[] = "myclass"; 

struct S 
{ 
    template<const auto& name> 
    const auto& get() 
    { 
     static_assert(is_str_literal_v<decltype(name)>, "usage: get<var name>()"); 
     if constexpr(samestr(name, ::myint)) 
      return myint; 
     if constexpr(samestr(name, ::mydouble)) 
      return mydouble; 
     if constexpr(samestr(name, ::myclass)) 
      return myclass; 
    } 

    int myint; 
    double mydouble; 
    char myclass; 
}; 

int main() 
{ 
    S s; 
    s.myint = 42; 
    s.mydouble = 10.0; 
    s.myclass = 'c'; 
    cout << s.get<myint>() << endl; 
    cout << s.get<mydouble>() << endl; 
    cout << s.get<myclass>() << endl; 
}

Live

这使用C++ 17。

这很酷，谢谢:) – charlestoncrabb

答

经过一番进一步的讨论后，我不得不恭敬地评论和回答之前的评估......自从发布这个问题以来，遇到很多功能在标准C库其中void *类型很容易使用（http://www.cplusplus.com/reference/cstdlib/qsort/），更不用说它是malloc的返回类型（可能是C/C++中使用最广泛的函数？），它依赖于程序员类型转换。另外，据我所知，std :: any是一个新的C++ 17类，所以6个月前你如何回答这个问题？

C++类型铸造指向常量变量的指针

相关推荐