io — C ++ Перегрузка операторов I / 0: преодоление неоднозначности в прошлом

Вы не можете сделать это, по крайней мере, не так просто.

Это оставляет вам два варианта: использовать две функции, которые создают строку и возвращает ее, или создавать структуру потокового манипулятора.

Создать набор функций форматирования, который возвращает строку, которая затем используется для вывода, просто с помощью std::ostringstream:

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

Создание структур манипуляторов немного сложнее, но также может быть более гибким и мощным:

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_;
};

В обоих случаях вы можете использовать его одинаково:

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

Вы можете сделать это, возвращая прокси (для обеспечения адаптации) из вашего класса, используя make-функции и используя:
оператор << (ostream, SomeClass :: Proxy) в качестве оператора вывода. Я поработаю над примером кода.

Таким образом, вам не нужно выставлять внутренности вашего класса тоже. Ничего плохого в том, чтобы сделать оператора << друзья …

Пример:

#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;
}

Увидев несколько хороших ответов и учитывая, что ostream объект и operator<< не может знать, какой тип использовать, и, полагая, что пользователь решит отобразить информацию для своих нужд, я пошел другим путем; однако решение, которое я нашел, которое работает для моих текущих потребностей, было поддержано и вдохновлено всеми теми, кто оставил отличные ответы на эту проблему.

Направление, которое я выбрал, было таким; Я добавил enum в мой класс непосредственно с 3 типами. Я добавил публичную функцию, которая выводит строку и принимает enum введите в качестве параметра. Я добавил ostream operator<< в мой класс и параметр, который он принимает, является typename на мои занятия enum, Я использую функцию out, чтобы разветвлять мои 3 различных способа отображения информации. Так что теперь в другом разделе кода, который использует этот объект, я могу передать экземпляр, вызывающий функцию out, которая возвращает строку, передавая требуемый тип. Мой класс теперь выглядит так:

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 );

}; // SomeClassstd::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

Я не знаю, связано ли это с моим классом в моем проекте, будучи template или как operator<< реализовано, но я должен был использовать typename с в объявлении / определении функции для его работы, так что это выглядит в моем коде, за исключением имени класса.

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

Я ценю всю помощь и предложения, которые вы все предложили, и я принимаю тот совет, который был дан всем сердцем, спасибо всем.

редактировать

Теперь, если я хочу сделать это немного проще для пользователя: я мог бы переместить свою функцию out в приватный раздел; Напишите 3 обертки или напечатайте функции, которые не принимают никаких параметров, но они устанавливают переменную в закрытый метод.

Добавьте некоторый способ, например, член к вашему классу, чтобы решить выходной формат:

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

private:
mutable OutputStyle style_ = M_256;

Добавьте некоторый способ, например, оператор вызова функции, чтобы установить это:

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

Сделать << оператор, чтобы рассмотреть это:

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;
}
}

Затем вы можете изменить его до или во время вывода:

    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;