Распространенные ошибки

x = sin( 90 ); // x = 0.893997. Имелось ввиду 90 градусов, а функция sin принимает в радианах.

x = sin( 90 * M_PI / 180 ); // x = 1

class A {
public:
    int x;
    A() {
        x = 11;
    }
 
    A( int v ) {
        x = v;
    }
};
 
class B : public A {
public:
    B() {}
    B( int v ) {
        A::A( v );  // такой вызов 
        A();        // или такие
        A::A(); 
    }
};
 
int main()
{
    B b( 1 );
    std::cout << b.x;   // x по прежнему = 11.
}

class A {
public:
    int x;
    A(): x( 11 ) {}
    A( int v ) : x( v ) {}
};
 
class B : public A {
public:
    B() {}
    B( int v ) : A( v ) {}
};
 
int main() {
    B b( 1 );
    std::cout << b.x;   // x = 1
}

    int x = -5;
    unsigned int y = 100;
    if ( x < y ) // Результат false 
    ...

class B
{
    int value;
    virtual int f() const { return 1; } 
 
public:
    B() { value = f(); }
    int getValue() const { return value; }
};
 
class D : public B
{
    virtual int f() const { return 2; } 
};
 
int main()
{
    D d; 
    cout << d.getValue() << endl; // Выводит 1, а не 2
}

// допустимо и так:
for ( int i = 0; i < n; ++i )
    arr[i] = i * i;
 
// и так:
for ( int i = 0; i < n; ++i )
{
    arr[i] = i * i;
}

for ( int i = 0; i < n; ++i )
    arr[i] = i * i;    // будет выполняться на каждом витке цикла
    std:: cout << "Value of " << i + 1 << " element is " << arr[i];    // выполнится после цикла

for ( int i = 0; i < n; ++i )
{   // оба оператора будут выполняться на каждом витке цикла:
    arr[i] = i * i;
    std:: cout << "Value of " << i+1 << " element is " << arr[i];
}

if ( x == 0 )
    if ( y == 2 )
        printf ( "a\n" );
else
    printf ( "b\n" );

if ( x == 0 )
{
    if ( y == 2 )
        printf( "a\n" );
} else {
    printf( "b\n" );
}

int f( int * a ) {
    return sizeof a / sizeof *a;
}
 
int main() {
    int a[] = { 1, 2, 3 };
    std::cout << sizeof a / sizeof *a << '\n';  // 3
    std::cout << f( a );                    // 1
}

int f( int * a, int size ) {
    return size;
}
int main() {
    int a[] = { 1, 2, 3 };
    std::cout << f( a, sizeof a / sizeof *a );      // 3
}

#include <iostream>
template <typename T, std::size_t size>
std::size_t arr_size( T(&)[size] ) { return size; }
int  main()
{
    int arr[] = { 1, 2, 3, 4 };
    std::cout << arr_size( arr ) << std::endl;
    return 0;
}

#include <iostream>
template <typename T>
int f( T & a ) {
    return sizeof( a ) / sizeof( a[0] );
}
 
int main() 
{
    const int N = 5;
    const int M = 15;
    char a[N];
    std::cout << f( a ) << std::endl;
    char b[M];
    std::cout << f( b ) << std::endl;
    return 0;
}

#include <iostream> 
 
struct Test
{
    int x;
    int y;
    Test ( int y_ ) : y( y_ ) , x( y * 2 ) {}
};
     
int main() {
    Test t( 10 );
    std::cout << t.x << std::endl;
    std::cout << t.y << std::endl;
}

void foo_create( int * Arr ) {
    Arr = new int [10];
    for ( int i = 0; i < 10; i++ ) Arr[i] = i;
}
 
void foo_delete( int * Arr ) {
    delete [] Arr;
    Arr = NULL;
}
 
int main() {
    int * Ptr;
    foo_create( Ptr );
    for ( int i = 0; i < 10; i++ ) cout << Ptr[i] << "  ";
    foo_delete( Ptr );
    return 0;
}

#include <iostream>
void foo_create( int ** ptr_to_ptr )
{
    *ptr_to_ptr = new int [10];
    for ( int i = 0; i < 10; i++ ) (*ptr_to_ptr)[i] = i;
}
 
void foo_delete( int ** ptr_to_ptr )
{
    delete [] *ptr_to_ptr;
    *ptr_to_ptr = nullptr;
}
 
int main()
{
    int * Ptr;
    foo_create( &Ptr );
    for ( int i = 0; i < 10; i++ ) std::cout << Ptr[i] << "  ";
    foo_delete( &Ptr );
    std::cout  << Ptr <<  std::endl;
}

#include <iostream>
 
void foo_create( int * & Arr )
{
    Arr = new int [10];
    for ( int i = 0; i < 10; i++ ) Arr[i] = i;
}
 
void foo_delete( int * & Arr )
{
    delete [] Arr;
    Arr = nullptr;
}
 
int main()
{
    int * Ptr;
    foo_create( Ptr );
    for ( int i = 0; i < 10; i++ ) std::cout << Ptr[i] << "  ";
    std::cout <<  std::endl;
    foo_delete( Ptr );
    std::cout <<  Ptr << std::endl;
}

class A
{
private:
    int * x; // указатель на массив
    int n;
 
public:
    A() : x( 0 ), n( 0 ) {}
    A( int N ) : n( N )
    {
        x = new int [N]; // под массив выделяется память - нужен деструктор для ее удаления
        for ( int i = 0; i < N; i++ )
            x[i] = i;
    }
 
    ~A() // Создаем деструктор
    {
        delete [] x;
    }
 
    A( const A & a ) : n( a.n ) //  Обязательный копиконструктор (раз есть деструктор)
    {
        x = new int [a.n];
        for ( int i = 0; i < a.n; i++ )
            x[i] = a.x[i];
    }
 
    A & operator = ( const A & a ) // Обязательный оператор присвоения (раз есть деструктор)
    {
        if ( this == &a ) 
            return *this; // присвоение самому себе, ничего делать не надо
 
        delete [] x;
        n=a.n;
        x = new int [a.n];
        for ( int i = 0; i < a.n; i++ )
            x[i] = a.x[i];
 
        return *this;
    }
 
    A operator + ( A & a ) // слияние массивов 
    {
        A c;
        c.n = this->n + a.n;
        c.x = new int [c.n];
 
        int i = 0;
        for ( ; i < this->n; i++ )
            c.x[i] = this->x[i];
 
        int j = 0;
        for ( ; i < c.n; i++, j++ )
            c.x[i] = a.x[j];
 
        return c; // для передачи по значению используется копиконструктор
    }
};
 
int main()
{
    A a1( 2 ), a2( 3 );
    A a3;
        a3 = a1 + a2; // используется оператор присвоения
    return 0;
}

char ch = 'z';
char S[255] = "TestString__";
 
strcat( S, (char *)ch ); // попытка объединить строку с символом
std::cout << S << "\n";

char ch = 'z';
char S[255] = "TestString__";
int L = strlen( S );
S[L] = ch;
S[L + 1] = 0;
std::cout << S << "\n";

char ch = 'z';
char S[255] = "TestString__";
char temp[2] = "";
temp[0] = ch;
temp[1] = 0; // Обязательно
 
strcat( S, temp );
std::cout << S << "\n";

#include <iostream>
 
class A
{
public:
    A() { std::cout << "A()"; }
    ~A() { std::cout << "~A()"; }
};
 
class B : public A
{
public:
    B() { std::cout << "B()"; }
    ~B() { std::cout << "~B()"; }
};
 
int main()
{
    A * p = new B;
    delete p;
    // выведет A()B()~A()
}

virtual ~A() { std::cout << "~A()"; }

bool GetImageSize( const char * fileName, int & width, int & height )
{
    width = height = 42;
    return true;
}
 
int main ()
{
    int width = 0, height = 0;
    std::cout << GetImageSize( "tmp.jpg", width, height ) << " " << width << " " << height;
}

#define VAR  5 // так делать не рекомендуется 
#define VAR  5 /* так можно */

int x = VAR;

int x = 5 // так делать не рекомендуется ;

int x = 5  /* так можно */;

#define VAR /*так можно прокоментировать*/  \
   /*и так можно прокомментировать */5

#define VAR /*так можно прокоментировать*/  \
   /*и так можно прокомментировать */5 // comment