ошибка: нет подходящей функции для вызова ‘EVString::EVString(EVString)’
замечание: претенденты: EVString::EVString(EVString&)
замечание:              EVString::EVString(VString)

MSV>ошибка: нет подходящей функции для вызова ‘EVString::EVString(EVString)’
MSV>замечание: претенденты: EVString::EVString(EVString&)
MSV>замечание:              EVString::EVString(VString)
MSV>

12.8/2
A non-template constructor for class X is a copy constructor if its first parameter is of type X&, const X&, volatile X& or const volatile X&, and either there are no other parameters or else all other parameters have default arguments (8.3.6).106) [Example: X::X(const X&) and X::X(X&, int=1) are copy constructors.

12.8/3
A declaration of a constructor for a class X is ill-formed if its first parameter is of type X and either there are no other parameters or else all other parameters have default arguments.

/* со скобками */
if ( !(f = fopen ( "123", "w" )) )

/* убрал отрицание; без скобок */
if ( f = fopen ( "123", "w" ) )

warning: suggest parentheses around assignment used as truth value

/* убрал отрицание */
if ( ( f = fopen ( "123", "w" ) ) )

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

#include <stdio.h>

main () { // без int
    int a = 0, b = 0;
    printf("var_a = %x\n", a, b++);
}

• -Wformat, отвечающий за проверку printf, scanf и т.п.;
  
• -Wreturn-type, отвечающий за ругательство на неявный int;

‘-Wall’ turns on the following warning flags:

-Waddress
-Warray-bounds (only with ‘-O2’)
-Wc++0x-compat // для C не поставить — будет безболезненно
-Wchar-subscripts
-Wimplicit-int
-Wimplicit-function-declaration
-Wcomment
-Wformat // речь в посте выше шла об этом флаге...
-Wmain (only for C/ObjC and unless ‘-ffreestanding’)
-Wmissing-braces
-Wnonnull
-Wparentheses
-Wpointer-sign
-Wreorder
-Wreturn-type // ...и об этом.
-Wsequence-point
-Wsign-compare (only in C++)
-Wstrict-aliasing
-Wstrict-overflow=1
-Wswitch
-Wtrigraphs
-Wuninitialized
-Wunknown-pragmas
-Wunused-function
-Wunused-label
-Wunused-value
-Wunused-variable
-Wvolatile-register-var

нет подходящей функции для вызова ‘MSL::SetVal(EVString, MString&, MSLKValLine&)’
претенденты: bool MSL::SetVal(EVString&, VString, MSLKValLine&)
bool MSL::SetVal(EVString&, VString)

ошибка: нет подходящей функции для вызова ‘crbil::add(crbi)’
280: замечание: претенденты: void crbil::add(crbi&)
284: замечание: void crbil::add(int, char*)
288: замечание: void crbil::add(int, char*, int, char*)

ошибка: вызов перегруженной ‘MString(HLString&)’ имеет неоднозначную трактовку
претенденты: MString::MString(const VString&)
MString::MString(const MString&)
MString::MString(unsigned int) <near match>
...

class A{
...
bool sendping(crbi &or);
...
};

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

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 );

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