A>>crbil foo;
A>>foo.add(crbi());
A>>

crbi tmp = orb.geto(0);
cl.add(tmp);

printf("var_a = %x\n", a), b++;

MSV>дадада, кто написал, тот и виноват.

reinterpret_cast<long>

#define timeout(delay)          wtimeout(stdscr,delay)

void* f = reinterpret_cast<void*> ( someFunc );

AF>void* f = reinterpret_cast<void*> ( someFunc );
AF>

void (*p)();
void* v = reinterpret_cast<void*> ( p ); // error: invalid type conversion
long l = reinterpret_cast<long> ( p ); // Ok

bool RunFunc(..., Val const & retd = Val());

bool RunFunc(..., Val const & retd = Val())
{
   Val & retd_ = const_cast<Val &>(retd);
}

MSV>но за такие дела я смотрю на компилятор как на врага.

a = 2 + 2

some_class1(5) + some_class2(4)

my_string operator+(my_string const & a, other_string const & b) // const, ибо мы не изменяем слагаемые, мы формируем из них результат
{
    my_string result(a.size() + b.size());
    // операции по объединению строк
    return result; // в результате my_string, ибо мы прибавляем к ней
}

other_string operator+(other_string const & a, my_string const & b) // const, ибо мы не изменяем слагаемые, мы формируем из них результат
{
    other_string result(a.size() + b.size());
    // операции по объединению строк
    return result; // в результате other_string, ибо мы прибавляем к ней
}

other_string const & res = other_string("bla-bla") + my_string("bla-bla"); // будет работать
other_string res = other_string("bla-bla") + my_string("bla-bla"); // будет работать

my_string const & res = my_string("bla-bla") + other_string("bla-bla"); // ок
my_string res = my_string("bla-bla") + other_string("bla-bla"); // ок

my_string & res = my_string("bla-bla") + other_string("bla-bla"); // бамс, ошибка!

class MString;

class HLString
{
public:
    HLString()
    {}
    HLString(char const * str)
        : buf_(str)
    {}
    HLString const & add(char const * str) const
    {
        buf_ += str;
        return *this;
    }
    HLString const & add(HLString const & str) const
    {
        buf_ += str.data();
        return *this;
    }
    std::string const & data() const
    {
        return buf_;
    }
    HLString const & add(MString const & str) const;
private:
    // для буфера использовал стандартную строку, здесь показана только суть
    mutable std::string buf_; // mutable позволит менять данные в константных объектах
};


class MString
{
public:
    MString()
    {}
    MString(char const * str)
        : buf_(str)
    {}
    MString const & add(char const * str) const
    {
        buf_ += str;
        return *this;
    }
    MString const & add(MString const & str) const
    {
        buf_ += str.data();
        return *this;
    }
    std::string const & data() const
    {
        return buf_;
    }
    MString const & add(HLString const & str) const;

private:
    // для буфера использовал стандартную строку, здесь показана только суть
    mutable std::string buf_; // mutable позволит менять данные в константных объектах
};


MString const & MString::add(HLString const & str) const
{
    buf_ += str.data();
    return *this;
}

HLString const & HLString::add(MString const & str) const
{
    buf_ += str.data();
    return *this;
}

void Drawn(MString const & a)
{
    std::cout << a.data() << std::endl;
}

int main()
{
    HLString comm("test");

    Drawn(MString().add("Unknown command '").add(comm).add("'\r\n\r\n"));

    return 0;
}

void f(int& c);
f(42);

void increment(int& x)
{
    ++x;
    cout << x << endl;
}

int i = 42;
increment(i);      // 43
cout << i << endl; // 43

double d = 42;
increment(d);      // 43
cout << d << endl; // 42