指向成员的指针上的 const_cast 是否安全？

Question

在下面的代码中，一个对象的非const方法调用了同一个对象的const方法，该方法返回一个指向对象字段的const指针，然后这个返回的指针被强制转换为非const 版本——这是一种类似于此答案中的技术：Elegant solution to duplicate, const and non-const, getters? [duplicate]。但是，由于我将指针放入复杂的数据结构中，我不确定它是否真的有效。会吗？

class Struct {
private:
    Field f, g;

    std::map<std::string, const FieldBase*> const_fields_t;
    std::map<std::string, FieldBase*> fields_t;

public:
    const_fields_t get_fields() const {
        return const_fields_t { { "f", &f }, { "g", &g } };
   }

   fields_t get_fields() {
        const Foo* = this;
        fields_t result;

        foreach(auto& v : const_this->get_fields()) {
            result[v->first] = const_cast<FieldBase*>(v->second);
        }
        return result;
   }
};

Answer 1

是的，（我稍微清理了你的代码）：

#include <string>
#include <functional>
#include <iostream>
#include <map>
using namespace std;

class FieldBase {public: virtual string get_data() = 0; };
class Field : public FieldBase { public: string data; virtual string get_data() { return data; } };

class Struct {
public:
    Field f, g;

    typedef std::map<std::string, const FieldBase*> const_fields_t;
    typedef std::map<std::string, FieldBase*> fields_t;

public:
    const_fields_t get_fields() const {
        cout << "const get_fields() called" << endl;
        return const_fields_t { { "f", &f }, { "g", &g } };
   }

   fields_t get_fields() {
        cout << "non-const get_fields() called" << endl;
        auto const_this = static_cast<const Struct*>(this);
        fields_t result;

        for(auto& v : const_this->get_fields()) {
            result[v.first] = const_cast<FieldBase*>(v.second);
        }
        return result;
   }
};

int main ()
{
    Struct a;
    a.f.data = "Hello";
    a.g.data = "World";

    Struct::fields_t obj = a.get_fields();

    cout << obj["f"]->get_data() << endl;
    cout << obj["g"]->get_data() << endl;

}

Live example

您基本上让const 函数充当网关，以获取您需要的值，然后抛弃常量。这也适用于您的目的，因为指针将被解构并存储在新地图中。

请记住，可能有更好的解决方案不涉及上述所有复制。