пытаюсь написать std:out и файл одновременно

Проблема

ofstream::operator << (var);

Это ваше использование ofstream::operator<< в качестве квалифицированного вызова функции. Вы требуете, чтобы функция поиска нашла функцию-член ofstream; наилучшее совпадение, которое является членом, - это void*, тогда как специализация для char*, которая печатает фактическое содержимое строки, является свободной функцией (т. е. не функцией-членом).

Вы обнаружите ту же проблему, если сделаете это и с cout:

std::cout.operator<<(var);

Решение

Это может сделать это:

static_cast<ofstream&>(*this) << var;

потому что вы по-прежнему используете обычный синтаксис оператора (со всем вытекающим из этого разрешением перегрузок), но делаете это с ofstream в качестве операнда LHS.

Хотя на самом деле я его не тестировал.

Вывод

Кроме того, ваша operator<< тоже должна быть бесплатной функцией, чтобы соответствовать этому соглашению.

So:

struct OutputAndConsole : std::ofstream
{
    OutputAndConsole(const std::string& fileName)
       : std::ofstream(fileName)
       , fileName(fileName)
    {};

    const std::string fileName;
};

template <typename T>
OutputAndConsole& operator<<(OutputAndConsole& strm, const T& var)
{
    std::cout << var;
    static_cast<std::ofstream&>(strm) << var;
    return strm;
};

Я также позволил себе внести небольшие изменения в синтаксис.

Я не буду комментировать, почему ваш подход не работает, в основном потому, что его нельзя исправить, чтобы он работал должным образом. Основная проблема заключается в том, что вы не можете использовать свой поток, чтобы передать его чему-то, что ожидало std::ostream&, и при этом писать в оба потока. Однако существует относительно простой, хотя и не обязательно очевидный подход к реализации того, что вы на самом деле хотите: вы должны создать новый буфер потока, т. е. класс, производный от std::streambuf, и переопределить его функции overflow() и sync(). Вот полный код простой демонстрации:

#include <streambuf>

struct teebuf
    : std::streambuf
{
    std::streambuf* sb1_;
    std::streambuf* sb2_;

    teebuf(std::streambuf* sb1, std::streambuf* sb2)
        : sb1_(sb1), sb2_(sb2) {
    }
    int overflow(int c) {
        typedef std::streambuf::traits_type traits;
        bool rc(true);
        if (!traits::eq_int_type(traits::eof(), c)) {
            traits::eq_int_type(this->sb1_->sputc(c), traits::eof())
                && (rc = false);
            traits::eq_int_type(this->sb2_->sputc(c), traits::eof())
                && (rc = false);
        }
        return rc? traits::not_eof(c): traits::eof();
    }
    int sync() {
        bool rc(true);
        this->sb1_->pubsync() != -1 || (rc = false);
        this->sb2_->pubsync() != -1 || (rc = false);
        return rc? 0: -1;
    }
};

#include <fstream>
#include <iostream>

int main()
{
    std::ofstream fout("tee.txt");
    teebuf        sbuf(fout.rdbuf(), std::cout.rdbuf());
    std::ostream  out(&sbuf);
    out << "hello, world!\n";
}

Очевидно, что создание tee-stream можно красиво упаковать, но то, как это выглядит, не имеет большого значения. Важно то, что можно создать собственное место назначения (или источник) для IOStreams и что это не предполагает каких-либо попыток наследования от std::ostream. Единственная причина для наследования от std::ostream (или std::istream) состоит в том, чтобы упростить инициализацию потока с помощью пользовательского буфера потока.