使用“->”运算符时保留访问权限

我有两节课

template<class Type>
class SafePtr {
public:
    SafePtr() {}
    ~SafePtr() {}

    void Lock(Type* data, void* key)
    {
        if (!pKey)
        {
            pKey = key;
            pData = data;
        }
    }

    Type* Unlock(void* key) const
    {
        if (key == pKey)
            return pData;
    }

    Type* operator->() 
    {
        return pData;
    }

private:
    Type* pData = nullptr;
    void* pKey = nullptr;
};

template<class Type>
class SafePtrArray {
public:
    SafePtrArray() {}
    ~SafePtrArray() {}

    template<class... Args>
    SafePtr<Type> CreatePtr(Args&&... args)
    {
        Type* data = new Type(args...);
        ptrs.insert(ptrs.end(), data);

        SafePtr<Type> ptr;
        ptr.Lock(data, this);
        return ptr;
    }

    Type* UnlockPtr(const SafePtr<int>& ptr)
    {
        return ptr.Unlock(this);
    }

    void Destroy(const SafePtr<int>& ptr)
    {
        Type* pointer = ptr.Unlock(this);

        for (auto itr = ptrs.begin(); itr != ptrs.end(); itr++)
        {
            if ((*itr) == pointer)
            {
                delete pointer;
                ptrs.erase(itr);
            }
        }
    }

private:
    std::vector<Type*> ptrs;
};

目标是保护指针，以便用户可以访问其成员，但不能操作其实际指针（主要是过早删除它）。而且我还需要将所有指针存储在一个数组中，以便当父对象销毁时，我可以自动销毁所有分配的指针

为此我使用两个类，SafePtr and SafePtrArray. SafePtrArray创建并存储指针并将它们包装在SafePtr并将其返回给用户。SafePtr只是一个包装器并且不应该让用户可以访问底层指针，但将允许他们访问其成员。

一开始工作正常，但很快我就发现了这个错误，

int main()
{
    SafePtrArray<int> ptr;
    auto pInt = ptr.CreatePtr();
    int* i = pInt.operator->();     // Users can get access to the underlying pointer using this.

    ptr.Destroy(pInt);
}

有没有办法阻止用户访问底层类型并阻止他们在有权访问其成员的同时操作指针？

我仍然认为你试图解决一个问题，该问题更多地与 API/代码、文档的设计中可能存在的缺陷有关，或者与使用它的人缺乏 C++ 知识有关，而“解决方案”是缺点多于优点。

如果 C++ 程序员不知道什么是所有权或不尊重它，并盲目地删除对象或释放指针的内存，那么将会有更大的问题。您可能会将问题转移到代码的不同部分。

话虽如此，现在您可以做的最接近不暴露指针的事情是这样的：

（代码只是概念证明，所以像call可能需要改进）

#include <iostream>
#include <string>

struct Test {
  void foo(int x, int y, std::string str) {
    std::cout << x << " " << y << " " << str << std::endl;
  }

  double test = 0.5;
};

template <typename T>
struct Ptr {

  template <auto M, typename... Args>
  auto call(Args... args) {
    return (obj.*M)(std::forward<Args>(args)...);
  }

  template <auto M>
  auto get() { 
    return (obj.*M);
  }

protected:
  T obj;
};

int main() {
  Ptr<Test> p;

  p.call<&Test::foo>(1, 2, "hello");
  std::cout << p.get<&Test::test>() << std::endl;

  return 0;
}

但我仍然不认为这是一个好的方法。

用户仍然可以乱搞代码并做一些不好的事情，例如：

int main() {
  Ptr<Test> p;
  
  delete &p;

  return 0;
}

或者这肯定是未定义的行为，但这并不重要，因为删除不拥有的对象也会在某些时候导致未定义的行为：

template<typename T>
struct Ptr {
protected:
    T *obj;
}

template<typename T>
struct Ptr2 {
public:
    T *obj;
};

int main()
{
    Ptr<Test> p;
    Ptr2<Test> *p2 = reinterpret_cast<Ptr2<Test>*>(&p);
    
    std::cout << p2->obj << std::endl;
}

所以没有针对此类事情的保护措施。

除了显示的代码之外，还有一个建议反射 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0578r1.html该功能现在已完成，可以获取有关类型成员的信息，但这并未添加到 c++20 中，并且有一个用于元类 http://www.open-std.org/Jtc1/sc22/WG21/docs/papers/2018/p0707r3.pdf这也尚未包含在标准中。

有了这两个建议，您也许能够实现一些更好用的东西。但我对其好处的担忧仍然存在。