相关疑难解决方法(0)

注意:答案是按照特定的顺序给出的,但由于许多用户根据投票而不是给出的时间对答案进行排序,因此这里是答案的索引,它们是最有意义的顺序:

• C++中运算符重载的通用语法
• C++中运算符重载的三个基本规则
• 会员与非会员之间的决定
• 常见的运算符超载
  • 分配操作员
  • 输入和输出运算符
  • 函数调用运算符
  • 比较运算符
  • 算术运算符
  • 数组订阅
  • 指针类型的运算符
  • 转换运算符
• 重载新的和删除

_{(注意:这是Stack Overflow的C++常见问题解答的一个条目.如果你想批评在这种形式下提供常见问题解答的想法,那么发布所有这些的元数据的发布将是这样做的地方.这个问题在C++聊天室中受到监控,其中FAQ的想法一开始就出现了,所以你的答案很可能被那些提出想法的人阅读.)}

我理解正常的运算符重载.编译器可以直接将它们转换为方法调用.我不太清楚 - >运算符.我正在编写我的第一个自定义迭代器,我觉得需要 - >运算符.我看了一下stl源代码并实现了我自己的代码:

MyClass* MyClassIterator::operator->() const
{
    //m_iterator is a map<int, MyClass>::iterator in my code.
    return &(m_iterator->second);
}

然后我可以使用MyClassIterator的实例,如:

myClassIterator->APublicMethodInMyClass().

看起来编译器在这里做了两个步骤.1.调用 - >()方法获取一个临时的MyClass*变量.2.在temp变量上调用APublicMethodInMyClass使用其 - >运算符.

我的理解是否正确？

在驳斥了内置运算符不参与重载决策的概念之后,我正在仔细阅读第13.5节,并注意到没有任何部分operator->*.它只是一个通用的二元运算符.

它的弟兄operator->,operator*和operator[],都要求有非静态成员函数.这排除了通常用于从对象获得引用的操作符的自由函数重载的定义.但不常见的operator->*是遗漏了.

特别是,operator[]有许多相似之处.它是二进制的(它们错过了使它成为n-ary的黄金机会),它接受左侧的某种容器和右侧的某种定位器.除了禁止免费功能外,其特殊规则部分13.5.5似乎没有任何实际效果.(这种限制甚至排除了对交换性的支持!)

因此,例如,这是完全合法的:

#include <utility>
#include <iostream>
using namespace std;

template< class T >
T &
operator->*( pair<T,T> &l, bool r )
    { return r? l.second : l.first; }

template< class T >
 T & operator->*( bool l, pair<T,T> &r ) { return r->*l; }

int main() {
        pair<int, int> y( 5, 6 );
        y->*(0) = 7;
        y->*0->*y = …

我对C++比较陌生,仍然试图掌握语法.我一直在看一些运算符重载的例子,最近的智能指针实现.这是我正在看的一个非常通用的例子:

template < typename T > class SP
{
    private:
    T*    pData; // Generic pointer to be stored
    public:
    SP(T* pValue) : pData(pValue)
    {
    }
    ~SP()
    {
        delete pData;
    }

    T& operator* ()
    {
        return *pData;
    }

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

当重载引用运算符时,为什么类型为T&？类似地,当重载结构解除引用时为什么是类型T*？

我正在编写一个InputIterator,它实现了operator*和operator->等.

我的operator*返回一对(vector)元素的引用.因此,运算符*按值返回.

根据cppreference:

运算符 - >的重载必须返回一个原始指针,或返回一个对象(通过引用或按值),而运算符 - >又被重载.

那我该怎么回事？

我无法返回原始指针; 这对必须以某种方式返回.所以可能有一些包含operator->的包装器？它是否存在于标准库中,或者通常如何进行？

为什么std :: shared_ptr没有operator->*？

使用可变参数模板看起来很容易.

有关详细信息,请参阅此文章.

编辑:这似乎是一个潜在的重复:关于shared_ptr和指向成员运算符的指针` - >*`和`std :: bind`

我试图了解重载 - >运算符是如何工作的.我有以下课程

class Message {

public:
    Message(string message) :m_text(message) {}
    void printText() {
        cout << "text is " << m_text << endl;
    }
    string m_text;
};


class MessagePointerWrapper
{
public:

    MessagePointerWrapper(string message)  {
        m_message = std::make_unique<Message>(message);
    }

    Message* operator->() {

        return m_message.get();
    }

    std::unique_ptr<Message> m_message;

};

int main(int argc, char** argv)
{

    MessagePointerWrapper messageWrapper =  MessagePointerWrapper("Hello World");
    messageWrapper.m_message->printText();
    messageWrapper->m_text = "PQR";
    messageWrapper.m_message->printText();
}

该MessageWrapper级的->运算符重载以返回Message*.所以在主要方法中,当我调用messageWrapper->它返回的是一个Message*.通常当我有一个指针时,我需要使用->运算符或deference运算符来访问该对象.根据该逻辑,为了访问对象的m_text可用性Message …

根据13.3.1.2/8,或更好的脚注-129(强调我的):

[...]重复该过程,直到operator->函数返回非类类型的值.

我以为我知道它是如何operator->工作的(让我说,它基于返回类型的递归方式),但我发现我完全不知道它是如何工作的(我的意思是它的返回类型).

当我找到它时,我想知道是否可以真正定义和使用类似于double operator->()通用结构的东西S,因为我从未以这种方式使用过这样的运算符.
例如,请考虑以下代码:

struct S { 
    constexpr double operator->() noexcept {
        return 3.14;
    }
};

int main() {
    static_assert(3.14 == S{}.operator->(), "!");
}

语法非常难看,我看不到使用这样的运算符或类似运算符.

让程序员从这个运算符返回a double或a 的真正目的是什么float？
什么可能是他们的用途？

美好的一天,

我已经遇到这个问题,但我特别感兴趣的是"指向的对象成员..."作为上市型运营商在这里维基百科.

我从未在实际代码的上下文中看到过这个,所以这个概念对我来说有些深奥.

我的直觉说他们应该按如下方式使用:

struct A
{
    int *p;
};

int main()
{
    {
        A *a = new A();
        a->p = new int(0);
        // if this did compile, how would it be different from *a->p=5; ??
        a->*p = 5;
    }

    {
        A a;
        a.p = new int(0);
        // if this did compile, how would it be different from *a.p=5; ??
        a.*p = 5;
    }

    return 0;
}

但这不会编译因为p未声明.(见例)

任何人都可以提供一个在C++中使用operator - >*和/或.*的真实示例吗？

我已经Matrix为矩阵操作实现了一个类实现，到目前为止我可以重载普通（单个）运算符，例如+, *, ...

我想通过重载运算符 (.*) 来进行矩阵初等乘法，例如我可以写

Matrix A(5,3), B(5, 3), C;
C = A .* B;

在这种情况下，C 将保存来自 A 和 B 的逐个元素相乘的值（A 和 B 具有相同的维度）