const_cast(*this)

class Foo
{
   ...
};
 
std::wostream& operator<< (std::wostream &out, Foo &obj)
{
   // ... very-very many lines
}

std::wstring Foo::as_text() const
{
    std::wstringstream buf;
    buf << const_cast<Foo&>(*this); // const *this записать не дает
    return buf.str();
}

std::wostream& operator<< (std::wostream &out, Foo &obj)
{
   // ... very-very many lines
}

void Foo::fix()
{
    if (fixed)
        return;
    // анализ и некоторые исправления внутреннего состояния объекта при необходимости
    fixed = true;
}
 
std::wostream& operator<< (std::wostream &out, Foo &obj)
{
    obj.fix();
    out << ... ;
    return out;
}

#include <algorithm>
#include <fstream>
#include <iostream>
#include <iterator>
#include <string>
#include <vector>
 
const std::wstring TAB = L"    ", BR = L"<br/>";
 
// функция вывода отступов нужного уровня
std::wstring tab(const int n)
{
    std::wstring ident;
    for (int i=0; i < n; i++)
        ident += TAB;
    return ident;
}
 
struct td
{
    td(const int idnt = 0) : colspan(1), rowspan(1), color(), data(),
        ident(idnt) {}
    td(const int cols, const int rows, const std::wstring& col,
       const std::wstring& d, const int idnt = 0) :
        colspan(cols), rowspan(rows), color(col), data(d), ident(idnt) {}
 
    int colspan;        // объединение ячеек
    int rowspan;        // объединение столбцов
    std::wstring color; // цвет фона
    std::wstring data;  // содержимое внутри тега
    int ident;          // отступ (нужно при выводе)
};
 
struct IncIdent
{
    IncIdent(const int idnt) : ident(idnt) {}
    void operator()(td& t)
    {
        t.ident += ident;
    }
    int ident;
};
 
struct tr
{
    tr(int idnt = 0) : v_td(), ident(idnt) {}
    void add(const td& t)
    {
        td tmp = t;
        tmp.ident += ident + 1;
        v_td.push_back(tmp);
    }
    void pop()
    {
        v_td.pop_back();
    }
 
    std::vector<td> v_td; // ячейки
    int ident;            // отступ
};
 
struct table
{
    typedef std::vector<tr> vec_tr;
    typedef std::vector<tr>::iterator vec_tr_it;
    typedef std::vector<tr>::const_iterator vec_tr_cit;
 
    table(int idnt = 0) : v(), ident(idnt) {}
    void add(const tr& t)
    {
        tr tmp = t;
        tmp.ident += ident + 1;
        std::for_each(tmp.v_td.begin(), tmp.v_td.end(), IncIdent(ident + 1));
        v.push_back(tmp);
    }
    void pop()
    {
        v.pop_back();
    }
    void fix(); // добавляет colspan к недостающим ячейкам в конец
 
    vec_tr v;   // список строк ячеек (tr)
    int ident;  // отступ
};
 
void table::fix()
{
    bool allEQ = true;           // все tr содержат равное количество ячеек
    unsigned int max = v.begin()->v_td.size(); // максимальное значение количество ячеек
    for (vec_tr_cit cit = v.begin() + 1; cit != v.end(); ++cit)
    {
        // если вдруг какой-то tr содержит большее количество ячеек
        if (cit->v_td.size() > max)
        {
            // устанавливаем новый максимум и отмечаем что не все строки равны
            max = cit->v_td.size();
            allEQ = false;
        }
    }
 
    if (!allEQ)
    {
        // если нужно менять количество строк у недостающих элементов
        for (vec_tr_it it = v.begin(); it != v.end(); ++it)
            if (it->v_td.size() != max)
            {
                int cols = it->v_td.rbegin()->colspan;
                it->v_td.rbegin()->colspan += max - cols;
            }
    }
}
 
std::wostream& operator<< (std::wostream &out, const td &t)
{
    int n = t.ident;
    out << tab(n) << L"<td";
 
    // формируем атрибуты
    if (t.colspan != 1)
        out << L" colspan=\"" << t.colspan << "\"";
    if (t.rowspan != 1)
        out << L" rowspan=\"" << t.rowspan << "\"";
    if (!t.color.empty())
        out << L" bgcolor=\"" << t.color << "\"";
 
    // проверяем содержимое внутри тега
    if (t.data.empty())
        out << L"/>\n";
    else
    {
        n++;
        out << L">\n" << tab(n) << t.data << L"\n";
        n--;
        out << tab(n) << L"</td>\n";
    }
 
    return out;
}
 
std::wostream& operator<< (std::wostream &out, const tr &t)
{
    out << tab(t.ident) << L"<tr>\n";
    std::copy(t.v_td.begin(), t.v_td.end(),
        std::ostream_iterator<td, wchar_t>(out));
    out << tab(t.ident) << L"</tr>\n";
 
    return out;
}
 
std::wostream& operator<< (std::wostream &out, table &t)
{
    t.fix();
    out << tab(t.ident) << L"<table>\n";
    std::copy(t.v.begin(), t.v.end(), std::ostream_iterator<tr, wchar_t>(out));
    out << tab(t.ident) << L"</table>\n";
 
    return out;
}
 
int main()
{
    td td1, td2;
    td1.color = L"FF09AC";
    td1.data = L"Eniki beniki";
    td2.color = L"AABBCC";
    td2.colspan = 2;
    td2.rowspan = 3;
 
    tr tr1;
    tr1.add(td1);
    tr1.add(td2);
    tr1.add(td1);
 
    tr tr2 = tr1;
    tr2.pop();
 
    table tbl;
    //tbl.ident = 2;
    tbl.add(tr1);
    tbl.add(tr2);
 
    std::wcout << tbl;
}