Question

我对C ++很新，并且作为练习（也许最终是.Net实用程序）我正在做一个指针包装器（实际上是在C ++ / CLI中，但这也适用于C ++）。这个指针包装器（称为Apont）当前的行为就像指针一样，如下面的测试所示，如果标记为 1。和 2。的行被注释出：

int main(array<System::String ^> ^args)
{
    double ia = 10; double ip = 10;
    double *p = &ip;                // pointer analogy
    Apont<double> ^a =
        gcnew Apont<double>(ia);    // equivalent to what's below, without errors
    a = ~ia;/* 1.       IntelliSense: expression must have integral or unscoped enum type
                        error C2440: '=' : cannot convert from 'double' to 'Utilidades::ComNativos::Apont<T> ^'
                        error C2171: '~' : illegal on operands of type 'double'*/
    Console::WriteLine("ip = {0}; *p = {1}; ia = {2}; !a = {3}", ip, *p, ia, !a);
    ia = 20; ip = 20;
    Console::WriteLine("ip = {0}; *p = {1}; ia = {2}; !a = {3}", ip, *p, ia, !a);
    *p = 30;        // pointer analogy
    a->Valor = 30;  // does exacly what's below, without errors
    !a = 30;/* 2.   IntelliSense: expression must be a modifiable lvalue
                    error C2106: '=' : left operand must be l-value */
    Console::WriteLine("ip = {0}; *p = {1}; ia = {2}; !a = {3}", ip, *p, ia, !a);
    //a->Dispose();
    Console::ReadKey();
    p = nullptr;
    return 0;
}

我不喜欢这里有两件事，在代码注释中标有 1。和 2。，在有错误的行之前。 operator~（请参阅 1。）在Apont之外定义，如下所示：

template<typename T> static Apont<T>^% operator ~(T& valor)
{
    return gcnew Apont<T>(valor);
}

我认为这个必须在Apont之外定义，但我不确定。我无法理解它产生的错误（当然，这些是在使用中，而不是在定义中）。

要设置Apont实例引用的值，我必须使用属性（标记为 2。的行不起作用，仅在设置用法中出错）， Apont::Valor，相当于使用*p。我想要做的是当我使用*p获取或设置它指向的值时，使用!a对Apont具有相同的效果。这是Apont::operator!()目前的定义：

T operator !()
{
    return Valor;
}

正如您在 2。中所看到的（代码中的注释，在相应的错误之前），它不适用于设置值。也许我应该回复参考？创建另一个具有相同名称的运算符，可能在类之外？我尝试了几个选项，然而，我遇到了类似的错误，并且更加困惑。

问题是：如何创建一个行为类似于&的运算符（在本例中为~）和一个行为类似于*的运算符（在本例中为{{1} ，取消引用，但行为类似于!，您可以在下面看到旧的定义？）

Apont::Valor

Answer 1

如果我正确理解了您的代码，您希望运算符~返回指针包装器和运算符!的副本以作为取消引用吗？

在这种情况下，您可以在调用复制构造函数的operator ~类中定义一元Apont。如果你想要一个值，operator !必须确实返回一个引用。

我认为以下c ++代码定义了您要执行的操作（我将Apont重命名为A）：

#include <iostream>

template<typename T>
struct A {
    T* payload;

    A(T *ptr)
        :payload(ptr) {}
    A(const A&other)
        :payload(other.payload) {}

    T& operator !(){
        return *payload;
    }

    T* operator ~(){
        return payload;
    }
};

int main(){
#define PRINT(X) std::cerr << #X << " = " << X << std::endl
    int i = 0;
    PRINT(i);

    A<int> a(&i);
    !a = 1;
    PRINT(i);

    A<int> b = ~a;
    !b = 2;
    PRINT(i);
}

上面代码的输出是：

i = 0
i = 1
i = 2

根据您的评论，您说过您希望运算符!的行为与包装指针完全相同。您可以这样做，但随后语法会发生变化，您需要取消引用它以分配新值（因为它是一个指针......）。比如：

#include <iostream>

template<typename T>
struct A {
    T* payload;

    A(T *ptr): payload(ptr) {}

    // this now behaves like accessing the wrapped pointer directly
    T*& operator !(){
        return payload;
    }
};

int main(){
#define PRINT(X) std::cerr << #X << " = " << X << std::endl
    int i = 0;
    int j = 999;
    PRINT(i);

    A<int> a(&i);
    *(!a) = 1;  // note the change of syntax here
    PRINT(*!a); // and here

    !a = &j;    // but now you can change the wrapped pointer through the operator
    PRINT(*!a);
}

Answer 2

让我回顾一下新答案的清晰度。

解决!运算符非常简单，正如我在之前的回答中所说，只需添加引用。

因此，对于运算符~，目标是使其行为类似于&运算符，并调用指针包装类的构造函数。

我认为这是不可能的。对于用户定义的对象当然是可能的，但我认为不可能为内置类型重载一元运算符。因此，根据您的喜好，有三种解决方案：

第一个完全符合你的要求，但会破坏原始类型：

#include <iostream>

template<typename T>
struct A {
    T* payload;

    A()
        : payload(NULL){}
    A(T *ptr)
        : payload(ptr) {}

    T& operator !(){
        return *payload;
    }
};

// this will not work for primary types
template<typename T>
A<T> operator ~(T &b){
    return A<T>(&b);
}

struct B{
    int test;
};

int main(){
    B b; b.test = 4;

    A<B> a;
    a = ~b; // I think this is what you want
    std::cerr << (!a).test << std::endl;

    // this does not work
    //int i = 4;
    //A<int> a;
    //a = ~i;
}

第二种解决方案：使用复合赋值运算符。优点是副作用很小，缺点是这不是很直观，可能会打破你想到的漂亮设计。

#include <iostream>

template<typename T>
struct A {
    T* payload;

    A() : payload(NULL){}

    T& operator !(){
        return *payload;
    }
};

template<typename T>
A<T>& operator &=(A<T> &a, T& b){ // should be friend of the above
    a.payload = &b;
    return a;
}

int main(){
    int i = 3;
    A<int> a;
    a &= i;
    std::cerr << !a << std::endl;
}

第三种解决方案：重载基本赋值运算符。这更直观，但有很多副作用：

#include <iostream>

template<typename T>
struct A {
    T* payload;

    A() : payload(NULL){}

    T& operator !(){
        return *payload;
    }

    A<T>& operator = (T & b) {
        payload = &b;
        return *this;
    }
};

int main(){
    int i = 3;
    A<int> a;
    a = i;
    std::cerr << !a << std::endl;
}

有人可能有一个解决方法来劫持基本类型的运算符，但我想不出任何简单的解决方案。

Pointer Wrapper：解引用运算符

2 个答案: