C ++重载I / 0运算符：克服歧义

Question

I'm in the process of working on a class, and I have 3 arrays in my class where they all represent the same data but in a different format. I have overload the << operator that is declared outside of my class that takes a const refererence to it and not as a friend of this class.

SomeClass {
public:
    // Nameless Union - All 3 Arrays Are of The Same Exact Data Type
    // And All 3 Arrays Have The Same Exact Size. This Nameless Union
    // Uses The Same Memory Address For All 3 Arrays And Their Elements. 
    // So An Element Is Changed By One Array Type, It Is Expected And 
    // Accepted For It To Change The Others. This Is Not 3 Different 
    // Arrays, This Is Still 1 Array Of Size 256, Just Different 
    // Representations Or Different Ways To Access Them.
    union {
        int m_256[256];
        int m_16[16][16];
        int m_4[4][4][4][4];
    };

    SomeClass() { std::fill( std::begin( m_256 ), std::end( m_256 ), 0 ); }

}; // SomeClass

std::ostream& operator<<( std::ostream& out, const SomeClass& c ) {
    out << std::endl;

    for ( unsigned box = 0; box < 4; box++ ) {
        for ( unsigned slice = 0; slice < 4; slice++ ) {
            for ( unsigned row = 0; row < 4; row++ ) {
                for ( unsigned col = 0; col < 4; col++ ) {
                    out << "(" << box << "," << slice << "," << row << "," << col << ") = "
                         << c.m_4[box][slice][row][col] << std::endl;
                }
            }
        }
    } 
    return out;
} // operator<<

This is what I currently have. What I would like to be able to do is to also use the operator<< with this class as well, but to be able to distinguish a way to display the same data in a different format.

I know that you can not do this: by adding a 2nd

std::ostream& operator<<( std::ostream& out, const SomeClass& c ) {
    out << std::endl;
    for ( unsigned i = 0; i < 16; i++ ) {
        for ( unsigned j = 0; j < 16; j++ ) {
            out << "(" << i << "," << j << ") = " << c.m_16[i][j] << std::endl;
        }
    }
    return out;
} // operator<<

And a 3rd

std::ostream& operator<<( std::ostream& out, const SomeClass& c ) {
    out << std::endl;
    for ( unsigned u = 0; u < 256; u++ ) {
        out << u << " = " << m_256[u] << std::endl;
    }
    return out;
} // operator<<

Due to the fact that this is ambiguous. Yet I would like to have the functionality to display it in any of the 3 different formats.

Are there any work a rounds or solutions to this problem? I'd like to be able to just send the class object to the stream operator, and these types of operators can not accept additional parameters since they are binary operators and not a function.

Answer 1

You could just use an adaptor class to write the output. You could pass a format specifier into the constructor or differentiate by type. For example (differentiating by type):

struct SomeClassAs256 {
  SomeClass const& x_;

  explicit(SomeClass const& x) : x_(x) {}
};

And then have an operator<< implementation:

ostream& operator<<(ostream& os, SomeClassAs256 const& x) {
  ...
  return os;
}

And then you use it:

SomeClass x;
...
cout << SomeClassAs256(x) << endl;

Answer 2

You can't really do that, at least not that simply.

That leaves you with two choices: Use two functions which creates a string and returns it, or create a stream manipulator structure.

Creating a set of formatting functions which returns a string that is then use for the output is simple using std::ostringstream :

std::string format1(SomeClass const& c)
{
    std::ostringstream os;
    os << whatever you want ...
    return os.str();
}

Creating manipulator structures is a little more complicated, but can also be more flexible and powerful:

class format1
{
public:
    format1(SomeClass const& c)
        : c_(c)
    {}

    friend std::ostream& operator<<(std::ostream& os,
                                    format1 const& fmt)
    {
        os << some formated output here using `fmt.c_`...;
        return os;
    }

private:
    SomeClass const& c_;
};

In both cases you can use it the same way:

SomeClass c(...);
std::cout << format1(c) << '\n';

Answer 3

You can do this by returning a proxy (to provide the adaption) from your class using make functions and using: operator << (ostream, SomeClass::Proxy) as output operator. I'll work on some example code.

This way you don't need to expose the internals of your class too. Nothing wrong with making operator << friends...

Example:

#include <iostream>
class SomeClass {
    union {
        int m_256[256];
        int m_16[16][16];
        int m_4[4][4][4][4];
    };
public:

    SomeClass() { std::fill( std::begin( m_256 ), std::end( m_256 ), 0 ); }

    struct x256
    {
      const SomeClass& c_;
      explicit x256(const SomeClass& c): c_(c)
      {
      }
    };
    struct x16
    {
      const SomeClass& c_;
      explicit x16(const SomeClass& c): c_(c)
      {
      }
    };

    struct x4
    {
      const SomeClass& c_;
      explicit x4(const SomeClass& c): c_(c)
      {
      }
    };

    x256 output265() const
    {
      return x256(*this);
    }

    x16 output16() const
    {
      return x16(*this);
    }

    x4 output4() const
    {
      return x4(*this);
    }

    friend std::ostream& operator<<( std::ostream& out, const SomeClass::x256& c ) {
        out << std::endl;
        for ( unsigned u = 0; u < 256; u++ ) {
            out << u << " = " << c.c_.m_256[u] << std::endl;
        }
        return out;
    } // operator<<
    friend std::ostream& operator<<( std::ostream& out, const SomeClass::x16& c ) {
        //...
        return out;
    } // operator<<
    friend std::ostream& operator<<( std::ostream& out, const SomeClass::x4& c ) {
        //...
        return out;
    } // operator<<
}; // SomeClass

void testSomeClass()
{
  SomeClass someClass;

  std::cout << someClass.output265() << someClass.output16() << someClass.output4() << std::endl;
}

Answer 4

Add some way for example member to your class to decide output format:

public:
    enum OutputStyle 
    {
        M_256,
        M_16,
        M_4,
    };
    OutputStyle style() const {return style_;}

 private:  
     mutable OutputStyle style_ = M_256;

Add some way for example function call operator to set that:

public:
    SomeClass const& operator()(OutputStyle s) const
    {
        style_ = s;
        return *this;
    }

Make the << operator to consider it:

std::ostream& operator<<( std::ostream& out, const SomeClass& c ) 
{
    switch( c.style() )
    {
    default:
        assert(!"defective operator <<");
    case SomeClass::M_256:
        // ... output like M_256 here 
        break; 
    case SomeClass::M_16: 
        // ... output like M_16 here
        break; 
    case SomeClass::M_4:
        // ... output like M_4 here
        break;
    }
} 

Then you can change it before or during output:

    SomeClass x; // <- has style M_256

    x(SomeClass::M_16);

    std::cout << "current:" << x << std::endl
              << "with M_4:" << x(SomeClass::M_4) << std::endl;

Answer 5

After seeing some great answers and taking into the consideration that the ostream object and operator<< can not know which type to use and figuring that it would be decided by the user to display the information to their needs, I went a different route; however the solution that I have come up with that works for my current needs was aided and inspired by all of those who have left great answers to this problem.

The direction that I took was this; I added an enum to my class directly with the 3 types. I added a public function that outputs a string and takes the enum type as a parameter. I added the ostream operator<< to my class and the parameter that it takes is a typename to my classes enum . I use the out function to branch my 3 different ways to display the information. So now in a different section of code that uses this object, I can pass the instance calling the out function that returns a string by passing in the type wanted. My class now looks like this:

class SomeClass {
public:
    enum OutputType { x256, x16, x4 };

    union {
        int m_256[256];
        int m_16[16][16];
        int m_4[4][4][4][4];
    };

    std::string out( OutputType type ) const;

    std::ostream& operator<<( typename SomeClass::OutputType type );

}; // SomeClass


std::ostream& SomeClass::operator<<( typename SomeClass::OutputType type ) {
    return std::ostream << out(type );
} // operator<<

std::string SomeClass::out( OutputType type ) const {
    std::ostringstream out;
    out << std::endl;

    switch( type ) {
        case: x256: {
            // Print Format Here
            break; 
        }
        case x16: {
            // Print Format Here
            break;
        }
        case x4: {
            // Print Format Here
            break;
        }
        default: {
            // Error Message
            return out.str();
        }
    }
    return out.str();
 } // out

I don't know if it has to do with my class in my project being a template or the way the operator<< is implemented but I had to use typename with in the function declaration / definition for it to work, so this is what it looks like in my code except for the name of the class.

template< class T>
std::ostringstream& SomeClass<T>::operator<<( typename SomeClass<T>::Type type ) { 
    // Code Here
}

I appreciate all the help and suggestions that all of you have offered and I take that advice that was given to heart, thank you all.

Edit

Now if I wanted to make this a little easier on the user: I could move my out function to the private section; Write 3 wrapper out or print functions that doesn't take any parameters, but they set the variable to the private method.