// Бубен :)
#define __AST *
#define Cc __AST/  //Comment Close
#define Co /__AST  //Comment Open
#define _FUNCCALL(func, h, t) func(Co h Cc, Co t Cc)
// Конец Бубна

// Целывой макрос
FILE* logFile = 0;
#define LOGPRINT(x) \
   printf##x; \
   if (logFile) _FUNCCALL(fprintf, (Cc logFile Co), x);

// Используется как
LOGPRINT((Cc "Error code: %d. Error Message: %s\r\n", errCode, errMsg Co))

// Целывой макрос
FILE* logFile = 0;
#define LOGPRINT(x) \
   printf( Co x Cc ); \       // здесь было printf##x
   if (logFile) _FUNCCALL(fprintf, (Cc logFile Co), x);

V>а то не красиво смотрится

ACE_ERROR ((LM_ERROR, ACE_TEXT ("assertion failed \"%s\": %u != %u\n"),
                        message, i, j));

class LogOutput
{
   ...
};
LogOutput log_print;

log_print << "text: " << 5;

WM>>log_print << "text: " << 5;
WM>>

class null_ostream
{
public:
  template <typename T>
  null_ostream& operator<<(const T&) const
  {}
};

#ifdef WITH_LOGGING
log_ostream log_print;
#else
null_ostream log_print;
#endif

V>Кто подскажеть тому

#ifdef DEBUG
#    define LOGPRINT_FUNC printf
#else
#    define LOGPRINT_FUNC empty_func
inline void empty_func(...) {}
#endif

template<typename T1>
inline LOGPRINT(T1 t1) {
    LOGPRINT_FUNC(t1);
}

template<typename T1, typename T2>
inline LOGPRINT(T1 t1, T2 t2) {
    LOGPRINT_FUNC(t1, t2);
}

// и т.д.

null_stream() << non_inline_function1() + non_inline_function2()/non_inline_function3();

WM>>class LogOutput
WM>>{
WM>>   ...
WM>>};
WM>>LogOutput log_print;

WM>>log_print << "text: " << 5;
WM>>

#ifdef DEBUG
#define TRACE(x) get_trace_stream()<<x
#else
define TRACE(x)
#endif
...
int n;
TRACE("n=" << n);
// в этом случае немного неудобно, но жить можно
TRACE(("someFunc returned "<<someFunc(1,2,3)));

GA>#ifdef DEBUG
GA>#define TRACE(x) get_trace_stream()<<x
GA>#else
GA>define TRACE(x)
GA>#endif
GA>...
GA>int n;
GA>TRACE("n=" << n);
GA>// в этом случае немного неудобно, но жить можно
GA>TRACE(("someFunc returned "<<someFunc(1,2,3))); 
GA>

#ifdef DEBUG
#define TRACE() (false) ? std::cout : get_trace_stream()
#else
#define TRACE() (true) ? std::cout : std::cout
...
int n;
TRACE() << "n=" << n;

// Есть отладочная печать.
(false) ? std::cout : get_trace_stream() << "n=" << n;

(true) ? std::cout : std::cout << "n=" << n;

GA>Отличная идея , только я бы std::cout на какой-нибудь null_stream заменил бы (в случае, когда трассировка отключена).

std::cout;

GA>null_stream() << non_inline_function1() + non_inline_function2()/non_inline_function3();

logstream << "Hello world, we are flying at " << altitude << "m, "
  "the temperatures of engines are " << writeContainer(engineTemp, ", ") << "\n";

template <typename InIter>
class WriteRange
{
private:
  InIter begin_, end_;
  const char* separator_;
public:
  explicit WriteRange(InIter begin, InIter end, const char* separator)
  : begin_(begin), end_(end), separator_(separator)
  {}

  friend std::ostream& operator<<(std::ostream& stream, const WriteRange& wr)
  {
    InIter i = wr.begin_;
    stream << *i;
    for (++i; i != wr.end_; ++i)
    {
      stream << separator << *i;
    }
    return stream;
  }
};

template <typename Container>
WriteRange<typename Container::const_iterator>
writeContainer(const Container& container, const char* separator)
{
  return WriteRange<typename Container::const_iterator>(container.begin(), container.end(), separator);
}

C>Мы всё ещё говорим о логировании, или уже перешли к минимизирующим поверхность при заданном объёме представителям семейства непарнокопытных в условиях отсутствия атмосферного давления? Какие неинлайновые функции, какие побочные эффекты? Да тут use case примерно следующей сложности:

C>logstream << "Hello world, we are flying at " << altitude << "m, "
C>  "the temperatures of engines are " << writeContainer(engineTemp, ", ") << "\n";
C>

std::string lastErrorMsg() {
  // GetLastError(), FormatMessage и т.д. 
}
...
void foo() {
  trace_stream << lastErrorMsg();
}

namespace ThirdParty {
  class Something {
  public:
    std::string dump()const; //non-inline!
  };
}
...
void f(const ThirdParty::Something& smth) {
  log_stream << smth.dump();
  ...
}

WM>>class LogOutput
WM>>{
WM>>   ...
WM>>   operator bool () const { return true; }
WM>>};
WM>>LogOutput log_print;

WM>>log_print << "text: " << 5;
WM>>

class LogOutput
{
   ...
   operator bool () const { return true; }
};
LogOutput log_print;

ATLASSERT( log_print << "text: " << 5 );