Question

原始XY问题

在我需要使用object& operator<<(object& one, type& two);运算符重载的情况下，使用指针而不是引用的调整如下所示

object *operator<<(object* one, type& two);

原因是我的拷贝构造函数和赋值运算符被删除了，因为我正在实现一个类似于cout和cin的对象。什么是一个整洁的黑客做到这一点？我可能会使用Windows API样式代码，我将定义一个class pObject;，它是指向对象的指针的类包装器，但我想知道是否有更优雅的方式。

更多通用

我有T和T'以及不同数据类型的以下代码：

// foobar.h
namespace foo {
    class bar;
    extern foo::bar bExt;
}

foo::bar *operator<<(foo::bar *, T&);

namespace foo {
    class bar {
    public:
        static foo::bar *GetBar() { return new foo::bar; }
        void doSomething(T &t) {/* uses member variable mvar.*/}
    private:
        T' mvar; 
        friend foo::bar *::operator<<(foo::bar *, T &);
        bar() {/*initialize mvar appropriately*/} // default constructor

        bar(foo::bar const&) = delete;
        void operator=(foo::bar const&) = delete;
    };

}

//foobar.cpp
#include "foobar.h"

    foo::bar *foo::bExt = GetBar();
    foo::bar *operator<<(foo::bar *b, T&)
    {
        b->doSomething(T);
        return b;
    }

// main.cpp
#include "foobar.h"
int main()
{
    T x = /*something*/;
    foo::bExt << x; 
}

我希望的是，用户将无法创建bar的实例或修改foo::bExt，这不是常量，因为doSomething()会对其进行修改。最后，我需要一种方法来完成所有操作，同时仍然允许操作符重载object& operator<<(object& one, type& two);，但上面已经错误地使用了它。

进一步澄清

此段落下方发布的代码将无法编译，因为已删除了复制构造函数和赋值运算符。但是，这是我的代码所需的确切格式，因为extern变量foo::bExt需要通过一些复杂的构造函数过程来定义，然后用作重载运算符的参数，类似于外观和使用std::cout。快速解决方法是定义一个extern foo::bar *对象，如本段上面的代码所述，并使用指针作为运算符的参数。一个快速解决方法是每次用*foo::bExt作为参数调用operator<<时取消引用现在的指针extern对象*std::cout << 1;，但没有人*foo::bExt << 1;这样，g++ -std=c++11 <name>.cpp -o <name>也不应该#include <iostream> namespace foo { class bar; extern foo::bar bExt; } foo::bar &operator<<(foo::bar& ,int&); namespace foo { class bar { public: static foo::bar GetBar() { static foo::bar temp; return temp; } void print() {std::cout << v << std::endl;} private: int v; bar() : v(1965) {}; friend foo::bar &::operator<<(foo::bar &, int&); /* Commenting out the below copy constructor and * assignment operator allows the code to compile. */ bar(foo::bar const&) = delete; void operator=(foo::bar const&) = delete; }; foo::bar bExt = foo::bar::GetBar(); } foo::bar &operator<<(foo::bar &b, int &i) { b.v += i; return b; } int main() { int i = 50; foo::bExt << i; foo::bExt.print(); } 。它看起来既麻烦又不优雅，至少需要对替代方案进行调查。因此我的问题。不要接受我的话，请尝试以下代码

subset

as.POSIXct

Answer 1

正如在你的问题评论中所指出的那样（没有双关语），使用引用并没有错;但是，似乎你不明白为什么，所以我会解释它。

引用包含内置常量指针。这意味着当您传递对象的引用时，您的对象上既不会调用复制构造函数也不会调用赋值运算符;相反，它是被复制的引用内部指针，并且该对象本身仍然只有一个副本。因此，即使复制构造函数和/或赋值运算符被删除，您仍然可以使用对象的引用。

我希望这可以帮助您了解参考的工作原理。

编辑：实际完整解决方案

以下是基于问题中给出的第二个代码块的实际解决方案：

#include <iostream>

namespace foo
{
    class bar;
    extern foo::bar& bExt;
}

foo::bar &operator<<(foo::bar& ,int&);

namespace foo
{

    class bar
    {
    public:
        static foo::bar* GetBar()
        { 
            return new foo::bar();
        }
        void print() {std::cout << v << std::endl;}
    private:
        int v;
        bar() : v(1965) {};
        friend foo::bar&::operator<<(foo::bar&, int&);

        /* Commenting out the below copy constructor and
         * assignment operator allows the code to compile.
         */
        bar(foo::bar const&) = delete;
        void operator=(foo::bar const&) = delete;
    };
    foo::bar& bExt = *foo::bar::GetBar();
}

foo::bar &operator<<(foo::bar &b, int &i)
{
    b.v += i;
    return b;
}

int main()
{
    int i = 50;
    foo::bExt << i;
    foo::bExt.print();
}

希望这有帮助。

Answer 2

结果表明以下过载可以解决问题：

notificationView.setImageViewResource(R.id.recentAppButt, R.drawable.icon_with_blue_background)

object * operator＆lt;＆lt;（object * one，type＆amp; two）;

2 个答案: