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; 
}

輸出：

來源

2017-06-17 charlestoncrabb

對於必須維護此代碼的程序員，我感到很遺憾。對於像這樣的事情，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。

來源

2017-06-17 08:10:36

這很酷，謝謝:) – charlestoncrabb

經過一番進一步的討論後，我不得不恭敬地評論和回答之前的評估......自從發佈這個問題以來，遇到很多功能在標準C庫其中void *類型很容易使用（http://www.cplusplus.com/reference/cstdlib/qsort/），更不用說它是malloc的返回類型（可能是C/C++中使用最廣泛的函數？），它依賴於程序員類型轉換。另外，據我所知，std :: any是一個新的C++ 17類，所以6個月前你如何回答這個問題？

來源

2017-06-22 05:37:52 charlestoncrabb

C++類型鑄造指向常量變量的指針

回答

相關問題