operator must take exactly one argument

Question

a h   include  logic h       class A   friend ostream amp  operator lt  lt  ostream amp   A amp             logic cpp   include  a h      ostream amp  logic  operator lt  lt  ostream amp  os  A amp  a                When i compile  it says      std  ostream amp  logic  operator lt  lt  std  ostream amp   A amp    must take exactly one argument    What is the problem

User · Answer

I ran into this problem with templated classes. Here's a more general solution I had to use:

template class <T>
class myClass
{
    int myField;

    // Helper function accessing my fields
    void toString(std::ostream&) const;

    // Friend means operator<< can use private variables
    // It needs to be declared as a template, but T is taken
    template <class U>
    friend std::ostream& operator<<(std::ostream&, const myClass<U> &);
}

// Operator is a non-member and global, so it's not myClass<U>::operator<<()
// Because of how C++ implements templates the function must be
// fully declared in the header for the linker to resolve it :(
template <class U>
std::ostream& operator<<(std::ostream& os, const myClass<U> & obj)
{
  obj.toString(os);
  return os;
}

Now: * My toString() function can't be inline if it is going to be tucked away in cpp. * You're stuck with some code in the header, I couldn't get rid of it. * The operator will call the toString() method, it's not inlined.

The body of operator<< can be declared in the friend clause or outside the class. Both options are ugly. :(

Maybe I'm misunderstanding or missing something, but just forward-declaring the operator template doesn't link in gcc.

This works too:

template class <T>
class myClass
{
    int myField;

    // Helper function accessing my fields
    void toString(std::ostream&) const;

    // For some reason this requires using T, and not U as above
    friend std::ostream& operator<<(std::ostream&, const myClass<T> &)
    {
        obj.toString(os);
        return os;
    }
}

I think you can also avoid the templating issues forcing declarations in headers, if you use a parent class that is not templated to implement operator<<, and use a virtual toString() method.

User · Answer

A friend function is not a member function  so the problem is that you declare operator lt  lt  as a friend of A    friend ostream amp  operator lt  lt  ostream amp   A amp      then try to define it as a member function of the class logic   ostream amp  logic  operator lt  lt  ostream amp  os  A amp  a                      Are you confused about whether logic is a class or a namespace   The error is because you ve tried to define a member operator lt  lt  taking two arguments  which means it takes three arguments including the implicit this parameter  The operator can only take two arguments  so that when you write a  lt  lt  b the two arguments are a and b   You want to define ostream amp  operator lt  lt  ostream amp   const A amp   as a non-member function  definitely not as a member of logic since it has nothing to do with that class   std  ostream amp  operator lt  lt  std  ostream amp  os  const A amp  a      return os  lt  lt  a number

User · Answer

The problem is that you define it inside the class  which   a  means the second argument is implicit  this  and   b  it will not do what you want it do  namely extend std  ostream    You have to define it as a free function   class A                std  ostream amp  operator lt  lt  std  ostream amp   const A amp  a

User · Answer

If you define operator lt  lt  as a member function it will have a different decomposed syntax than if you used a non-member operator lt  lt    A non-member operator lt  lt  is a binary operator  where a member operator lt  lt  is a unary operator      Declarations struct MyObj  std  ostream amp  operator lt  lt  std  ostream amp  os  const MyObj amp  myObj    struct MyObj          This is a member unary-operator  hence one argument     MyObj amp  operator lt  lt  std  ostream amp  os    os  lt  lt   this  return  this         int value   8         This is a non-member binary-operator  2 arguments std  ostream amp  operator lt  lt  std  ostream amp  os  const MyObj amp  myObj        return os  lt  lt  myObj value      So     how do you really call them   Operators are odd in some ways  I ll challenge you to write the operator lt  lt       syntax in your head to make things make sense   MyObj mo      Calling the unary operator mo  lt  lt  std  cout      which decomposes to    mo operator lt  lt  std  cout     Or you could attempt to call the non-member binary operator   MyObj mo      Calling the binary operator std  cout  lt  lt  mo      which decomposes to    operator lt  lt  std  cout  mo     You have no obligation to make these operators behave intuitively when you make them into member functions  you could define operator lt  lt  int  to left shift some member variable if you wanted to  understand that people may be a bit caught off guard  no matter how many comments you may write   Almost lastly  there may be times where both decompositions for an operator call are valid  you may get into trouble here and we ll defer that conversation   Lastly  note how odd it might be to write a unary member operator that is supposed to look like a binary operator  as you can make member operators virtual      also attempting to not devolve and run down this path       struct MyObj          Note that we now return the ostream     std  ostream amp  operator lt  lt  std  ostream amp  os    os  lt  lt   this  return os         int value   8       This syntax will irritate many coders now      MyObj mo   mo  lt  lt  std  cout  lt  lt   Words words words       this decomposes to    mo operator lt  lt  std  cout   lt  lt   Words words words           or even further     operator lt  lt  mo operator lt  lt  std  cout    Words words words      Note how the cout is the second argument in the chain here     odd right

[c++] operator << must take exactly one argument

Examples related to c++

Examples related to operator-overloading

Examples related to iostream