C++ 通过提供“隐藏原始指针”；委托书；指针

有没有一种方法可以将原始指针隐藏在“代理”或“伪”指针后面，从而提供对原始指针功能的访问而不显示其地址

原始指针的管理类可能如下所示：

template<typename T>
class hidden_ptr
{
public:
    hidden_ptr(T *RawPointer);
    ~hidden_ptr();

    T *get()
    {
       return new proxy_pointer<T>(raw_pointer)
    }
};

模板
类隐藏\u ptr
{
公众：
隐藏的指针（T*RawPointer）；
~hidden_ptr（）；
T*get（）
{
返回新的代理指针（原始指针）
}
};

然后使用它：

class Foo
{
public:
    Foo();
    ~Foo();

    void do_bar();
    void do_bar2();
};

int main()
{
    Foo *raw_pointer = new Foo();
    hidden_ptr<Foo> hidden(raw_pointer);

    Foo *proxy = hidden.get();

    proxy->do_bar();
    proxy->do_bar2();

    delete proxy; //The raw pointer is still safe till the hidden object destructs
}

class-Foo
{
公众：
Foo（）；
~Foo（）；
void do_bar（）；
void do_bar2（）；
};
int main（）
{
Foo*原始指针=新Foo（）；
隐藏\u ptr隐藏（原始\u指针）；
Foo*proxy=hidden.get（）；
代理->do_bar（）；
代理->do_bar2（）；
delete proxy；//在隐藏对象销毁之前，原始指针仍然是安全的
}

---

如果有办法，代理将是什么样子？

有两种：和。尽管它们背后的总体意图是提供简单的资源管理，但它们满足了您的要求。

是的。这很容易。只需将指针成员设为私有，然后重载*和->运算符以取消对私有成员的引用。但这也是一件毫无意义的事情，是“中文盒子”编程的极端情况，在这种情况下，您创建的“抽象”实际上只是其他数据类型的别名或包装。

您可以这样做：

#include <iostream>

template<typename T>
class hidden_ptr
{
public:
    hidden_ptr() = delete;
    hidden_ptr(hidden_ptr const&) = delete;
    hidden_ptr(T data) : ptr_(new T{data}) {}
    void operator=(hidden_ptr const&) = delete;
    ~hidden_ptr() {delete ptr_;}

    T* operator->() {return ptr_;};
    void reset(T data) {this->~hidden_ptr(); ptr_ = new T{data};}
    void set(T value) {*ptr_ = value;}
    T get() {return *ptr_;}

private:
    T* ptr_;
};

class A
{
public:
    void print() {std::cout << "A::print" << std::endl;}    
};

int main() 
{
    hidden_ptr<int> ptr_int(5);
    hidden_ptr<A> ptr_a(A{});
    ptr_int.reset(10);
    std::cout << ptr_int.get() << std::endl;
    ptr_a->print(); 
}

#包括
模板
类隐藏\u ptr
{
公众：
隐藏的_ptr（）=删除；
hidden_ptr（hidden_ptr const&）=删除；
隐藏的ptr（T数据）：ptr（新的T{data}）{}
void运算符=（hidden_ptr const&）=删除；
~hidden_ptr（）{delete ptr；}
T*运算符->（）{return ptr_；}；
void reset（T data）{this->~hidden_ptr（）；ptr_=新T{data}；}
无效集（T值）{*ptr_u=值；}
T get（）{return*ptr_；}
私人：
T*ptr；
};
甲级
{
公众：
void print（）{std:：cout满足您目前提供的需求组合的唯一方法是使类
Foo
成为排序的双模式类：它应该能够充当主要（隐藏）对象，以及自身的公共代理，即另一个
Foo
对象的公共代理

一个相当“丑陋”的实现可能如下所示

class Foo
{
    Foo *redirect_to = nullptr;
    Foo(Foo *redirect_to) : redirect_to(redirect_to) { ... }

public:
    Foo() { ... }
    ~Foo() { ... }

    Foo *get_proxy() { return new(this); }

    void do_bar() {
      if (redirect_to) {
        return redirect_to->do_bar();
      ...
    }

    void do_bar2() {
      if (redirect_to) {
        return redirect_to->do_bar2();
      ...
    }

    ...
};

之后，您将能够创建和删除可通过
Foo*
指针访问的代理。是否将此类代理包装成任何类型的智能指针取决于您-这与问题无关

int main()
{
    Foo *raw_pointer = new Foo();

    Foo *proxy = raw_pointer->get_proxy();

    proxy->do_bar();
    proxy->do_bar2();

    delete proxy;
}

同样，如果您愿意，您可以将
隐藏的\u ptr
添加到混合中

仔细看一下上面的内容，马上就会发现它可以通过pImpl风格的实现更优雅地实现，在这种实现中，所有对象都成为指向隐藏实现类的代理.
回答问题：是的，在大多数情况下都有一种方法可以做到。听起来像是一个问题。不完全确定你想要完成什么，但你可以研究“智能指针”@Steve它将类似于共享的\u ptr，但是它不会返回实际的原始\u指针和引用计数，而是返回代理\u指针，从而隐藏您可能希望为此类任务重载
运算符->
的实际地址。它们与我所寻找的不完全相同，因为唯一的\u ptr不允许访问原始指针（这就是我想要的）但是它没有能力提供可以传递的原始数据（我想要）.shared_ptr确实提供原始指针，但如果在原始指针上调用delete，则会删除基础指针memory@Alex：您一开始说要隐藏原始指针。现在您说要访问原始指针并传递它。这有点自相矛盾。一旦您提供了对原始指针的直接访问，它不再是隐藏的。首先，您需要确定您想要的是什么。@AnT我确实想隐藏“实际”原始指针，但我想传递“代理”原始指针，该指针可以随意删除，而不会对“实际”指针造成任何后果PoTeTyu可以从两个智能指针中获取原始指针，使用<代码>获取<代码> >方法。编程？我相信你是对的。不幸的是，在模板样式中没有很好的重定向方法。遗憾的是，这是错误的：用户可以通过“operator->（）”方法访问指针=/