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;
}
输出:
5
3.14159
5
3.14159
10
所示的代码是非常,应当说,设计不良。
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;
}
这使用C++ 17。
这很酷,谢谢:) – charlestoncrabb
经过一番进一步的讨论后,我不得不恭敬地评论和回答之前的评估......自从发布这个问题以来,遇到很多功能在标准C库其中void *类型很容易使用(http://www.cplusplus.com/reference/cstdlib/qsort/),更不用说它是malloc的返回类型(可能是C/C++中使用最广泛的函数?),它依赖于程序员类型转换。另外,据我所知,std :: any是一个新的C++ 17类,所以6个月前你如何回答这个问题?
对于必须维护此代码的程序员,我感到很遗憾。对于像这样的事情,C++有'std :: any'。 – PaulMcKenzie
[std :: any usage](http://coliru.stacked-crooked.com/a/af4a1032226f6d60) – PaulMcKenzie
@PaulMcKenzie谢天谢地,这只是我玩指针而已... – charlestoncrabb