C++/Operations

Материал из Энциклопедия о программировании
Перейти к: навигация, поиск

Операции в C++ — всевозможные действия, что допустимы в языке программирования.

Объявление переменных

Объявить целочисленную переменную:

int nVar;

где int — тип, а nVar — имя переменной.

Принцип объявления переменных разных типов аналогичен:

type varNm;

где type — тип (напр., int), а varNm — имя переменной.

Объявление пяти переменных разных типов:

bool bVal;
char chVal;
int nVal;
float fVal;
double dVal;

Переменной типа void быть не может:

void vVal;

не будет работать, так как void не может использоваться в качестве типа переменной.

Инициализация переменных

При объявлении переменной можно сразу присвоить ей значение. Это называется инициализацией переменной. Важно понимать разницу, это не присваивание переменной значения, а именно инициализация переменной значением.

Язык C++ поддерживает 2 основных способа инициализации переменных.

  1. Копирующая инициализация (или «инициализация копированием») с помощью знака равенства =:
    int nVar = 5; // копирующая инициализация
  2. Прямая инициализация с помощью круглых скобок ():
    int nVar(5); // прямая инициализация

    Поскольку оператор «круглые скобки» (()) используется ещё и для вызова функции, поэтому с помощью них так можно задавать переменные только при их одновременном объявлении/декларировании и инициализации/определении (переменной), т.е. инициализировать их, иначе будет вызываться функция.

Прямая инициализация лучше работает с одними типами данных, копирующая инициализация — с другими.

uniform-инициализация переменных

Прямая или копирующая инициализация работают не со всеми типами данных (напр., нельзя использовать эти способы для инициализации списка значений).

В попытке обеспечить единый механизм инициализации, который будет работать со всеми типами данных, в C++11 добавили новый способ инициализации, который называется uniform-инициализация:

int var{5};

Инициализация переменной с пустыми фигурными скобками указывает на инициализацию по-умолчанию (переменной присваивается 0):

int var{}; // инициализация переменной по умолчанию значением 0 (ноль)

В uniform-инициализации есть еще одно дополнительное преимущество: нельзя присвоить переменной значение, которое не поддерживает её тип данных — компилятор выдаст предупреждение или сообщение об ошибке. Например:

int var{4.5}; // ошибка: целочисленная переменная не может содержать нецелочисленные значения

Используйте uniform-инициализацию.

Присваивание значений переменным

Когда переменной задаётся значение после её объявления (не в момент объявления), то это не инициализация, а присваивание (оно же «копирующее присваивание»). Присваивание переменной значения:

int nVar;
nVar = 5; // копирующее присваивание

Инициализация и присваивание это разные операции, несмотря на то, что обозначаются одним знаком (=). Присваивание уничтожает предыдущее значение, а инициализация ничего не уничтожает.

В языке C++ нет встроенной поддержки способов прямого/uniform-присваивания, есть только копирующее присваивание.

Объявление и инициализация нескольких переменных

Синтаксис C++ допускает указание переменных через запятую. Т.е. в одном стейтменте можно по очереди объявить и инициализировать сразу несколько переменных одного и того же типа данных, разделяя их имена запятыми. В заголовке функции так делать нельзя.

Объявление нескольких переменных

Можно один раз указать тип, а имена переменных перечислить через запятую. Например, следующие 2 фрагмента кода выполняют одно и то же:

int a, b;

и:

int a;
int b;

Инициализация нескольких переменных

Можно инициализировать несколько переменных в одном стейтменте:

int a = 5, b = 6;
int c(7), d(8);

В C++11 добавили uniform-инициализацию и для расширенного списка инициализаторов (extended initializer list):

int e{9}, f{10};

Определять каждую переменную в очереди не обязательно, можно и вполне достаточно просто объявить её и всё:

int a = 3, b, g = 15, h;
int c(4), d, i(17), j;
int e{5}, f, k{2}, l;

Сразу тут же можно инициализировать одну переменную значением другой, которая уже была инициализирована:

int a = 9, b, g = a, h = g;
int c(3), d(c), i, j(d);
int e{7}, f, k{e}, l;

Можно чередовать и комбинировать способы инициализации, и инициализировать одну переменную значением другой, которая была инициализирована другим способом:

int a = 9, b(3), c{7}, d = a, e = b, f = c, g(a), h(b), i(c), j{a}, k{b}, l{c}, m;

Или так:

int a, b = 16, c = b, d(c), e{d}, f = {e};
double g, h = 5.17, i = h, j(i), k{j}, l = {k};

Ошибки

При объявлении нескольких переменных по очереди в одном стейтменте часто совершают 3 ошибки:

  1. Указание каждой переменной одного и того же типа данных при инициализации нескольких переменных в одном стейтменте. Это не критичная ошибка, так как компилятор легко её обнаружит и сообщит об этом:
    int a, int b; // неправильно (ошибка компиляции)
    int a, b; // правильно
    
  2. Использование разных типов данных в одном стейтменте. Переменные разных типов должны быть объявлены в разных стейтментах. Эту ошибку компилятор также легко обнаружит:
    int a, double b; // неправильно (ошибка компиляции)
    int a; double b; // правильно (но не рекомендуется)
    // Правильно и рекомендуется (+ читабельнее)
    int a;
    double b;
    
  3. Инициализация двух переменных с помощью одной операции:
    int a, b = 5; // неправильно (переменная a остаётся неинициализированной)
    int a = 5, b = 5; // правильно
    

    Хороший способ запомнить эту ошибку и не допускать в будущем — использовать прямую или uniform-инициализацию:

    int a, b(5);
    int c, d{5};
    

    Этот вариант наглядно показывает, что значение 5 присваивается только переменным b и d.

Так как инициализация нескольких переменных в одной строке является отличным поводом для совершения ошибок, рекомендуется определять несколько переменных в одной строке только в том случае, если будете каждую из них инициализировать.

Избегайте объявления нескольких переменных в одной строке, если не собираетесь инициализировать каждую из них.