опитвайки се да напиша std:out и file едновременно

Проблемът

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) е да улесните инициализирането на поток с персонализиран буфер на потока.