Получить значение int из перечисления в c #

Значения перечислителей

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

#include <iostream>

enum Colors
{
COLOR_YELLOW, // присваивается 0
COLOR_WHITE, // присваивается 1
COLOR_ORANGE, // присваивается 2
COLOR_GREEN, // присваивается 3
COLOR_RED, // присваивается 4
COLOR_GRAY, // присваивается 5
COLOR_PURPLE, // присваивается 6
COLOR_BROWN // присваивается 7
};

int main()
{
Colors paint(COLOR_RED);
std::cout << paint;

return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

#include <iostream>
 

enumColors

{

COLOR_YELLOW,// присваивается 0

COLOR_WHITE,// присваивается 1

COLOR_ORANGE,// присваивается 2

COLOR_GREEN,// присваивается 3

COLOR_RED,// присваивается 4

COLOR_GRAY,// присваивается 5

COLOR_PURPLE,// присваивается 6

COLOR_BROWN// присваивается 7

};

intmain()

{

Colors paint(COLOR_RED);

std::cout<<paint;

return;

}

Результат выполнения программы:

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

// Определяем новый перечисляемый тип Animals
enum Animals
{
ANIMAL_PIG = -4,
ANIMAL_LION, // присваивается -3
ANIMAL_CAT, // присваивается -2
ANIMAL_HORSE = 6,
ANIMAL_ZEBRA = 6, // имеет то же значение, что и ANIMAL_HORSE
ANIMAL_COW // присваивается 7
};

1
2
3
4
5
6
7
8
9
10

// Определяем новый перечисляемый тип Animals

enumAnimals

{

ANIMAL_PIG=-4,

ANIMAL_LION,// присваивается -3

ANIMAL_CAT,// присваивается -2

ANIMAL_HORSE=6,

ANIMAL_ZEBRA=6,// имеет то же значение, что и ANIMAL_HORSE

ANIMAL_COW// присваивается 7

};

Обратите внимание, и имеют одинаковые значения. Хотя C++ это не запрещает, присваивать одно значение нескольким перечислителям в одном перечислении не рекомендуется

Совет: Не присваивайте свои значения перечислителям.

Правило: Не присваивайте одинаковые значения двум перечислителям в одном перечислении, если на это нет веской причины.

Параметры

identifier
Имя типа, присваиваемое перечислению.

type
Базовый тип перечислителей; все перечислители имеют один базовый тип. Может быть любым целочисленным типом.

Перечисление-список
Разделенный запятыми список перечислителей в перечислении. Каждый перечислитель или имя переменной в области должны быть уникальными. Однако значения могут повторяться. В неограниченном перечислении область является окружающей областью. в перечислении с заданной областью областью является сам список перечисления . В перечислении с заданной областью список может быть пустым, что фактически определяет новый целочисленный тип.

class
С помощью этого ключевого слова в объявлении указывается перечисление с областью видимости, и необходимо указать идентификатор . Можно также использовать ключевое слово вместо , так как они семантически эквивалентны в данном контексте.

Значения перечислителей

Каждому перечислителю в зависимости от его позиции в списке перечисления автоматически присваивается целочисленное значение. По умолчанию первому перечислителю присваивается целочисленное значение 0, а каждому последующему перечислителю присваивается значение на единицу больше, чем у предыдущего перечислителя:

Приведенная выше инструкция с выводит значение 4.

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

Обратите внимание, что в этом случае и имеют одинаковые значения. Когда это происходит, перечислители становятся неразличимыми – по сути, и взаимозаменяемы

Хотя C++ позволяет это, обычно следует избегать присвоения одного и того же значения двум перечислителям в одном перечислении.

Лучшая практика

Не назначайте перечислителям конкретные значения.

Лучшая практика

Не присваивайте одно и то же значение двум перечислителям в одном перечислении, если в этом нет веской причины.

Проверка ошибок

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

int array;
array = 4; // индекс 9 является некорректным (вне допустимого диапазона)!

1
2

intarray7;

array9=4;// индекс 9 является некорректным (вне допустимого диапазона)!

Однако, если мы знаем длину нашего массива, мы можем выполнять проверку передаваемого индекса на корректность в функции перегрузки оператора :

#include <cassert> // для assert()

class IntArray
{
private:
int m_array;

public:
int& operator[] (const int index);
};

int& IntArray::operator[] (const int index)
{
assert(index >= 0 && index < 10);

return m_array;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#include <cassert> // для assert()

classIntArray

{

private

intm_array10;

public

int&operator(constintindex);

};

int&IntArray::operator(constintindex)

{

assert(index>=&&index<10);

returnm_arrayindex;

}

В примере, приведенном выше, мы использовали стейтмент assert (который находится в заголовочном файле cassert) для проверки диапазона . Если выражение внутри assert принимает значение (т.е. пользователь ввел некорректный индекс), то программа немедленно завершится с выводом сообщения об ошибке, что лучше, нежели альтернативный вариант — повреждение памяти. Это самый распространенный способ проверки ошибок с использованием функций перегрузки.

Инициализация через исходное значение

Если вы объявили перечисление вместе с типом исходного значения, то перечисление автоматически получает инициализатор, который берет значение типа исходного значения (как параметр rawValue) и возвращает либо член перечисления либо nil. Вы можете использовать этот инициализатор, чтобы попытаться создать новый экземпляр перечисления.

В этом примере Uranus инициализируется через его исходное значение 7:

Конечно не все возможные значения Int найдут отклик в данном перечислении. Из-за этого инициализаторы исходных значений всегда возвращают опциональный член перечисления. В этом примере possiblePlanet типа Planet? или “опциональный Planet”.

Заметка

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

Если вы попытаетесь найти планету с номером позиции 11, то значение опциональной Planet, возвращенное исходным значением инициализатора, будет nil:

Этот пример использует привязку опционалов для попытки добраться до Planet с исходным значением 11. Выражение if let somePlanet = Planet(rawValue: 11) создает опциональную Planet и устанавливает значение somePlanet опциональной Planet, если она может быть восстановлена. В этом случае невозможно добраться до планеты с позицией 11, таким образом срабатывает ветка else.

Рекурсивные перечисления

Рекурсивные перечисления — это такие перечисления, экземпляры которого являются ассоциативным значением одного или более кейсов перечисления. Вы обозначаете такие кейсы перечисления при помощи ключевого слова indirect перед кейсом, что сообщает компилятору о том, что нужен дополнительный слой индирекции.

Например, ниже объявлено перечисление, которое хранит простые арифметические выражения:

Вы так же можете написать indirect прямо перед самим перечислением, что позволит обозначить то, что все члены перечисления поддерживают индиректность:

Перечисление может хранить три вида арифметических выражений: простое число, сложение двух выражений, умножение двух выражений. Члены addition и multiplication имеют два ассоциативных значения, которые так же являются арифметическими выражениями. Эти ассоциативные значения делают возможным вложение выражений. Например, выражение (5 + 4) * 2 имеет цифру справа от умножения и другое выражение слева от умножения. Поскольку данные вложены, перечисление использующееся для хранения данных, также должно поддерживать вложенность-это означает, что перечисление должно быть рекурсивными. Приведенный ниже код показывает как работает рекурсивное перечисление ArithmeticExpression для (5 + 4) * 2:

Рекурсивные функции — самый простой путь работать с данными, которые имеют рекурсивную структуру. Например, ниже приведен пример, как функция вычисляет арифметическое выражение:

Эта функция вычисляет простое число, просто возвращая ассоциативное значение. Она вычисляет сложение или умножение, вычисляя выражение по левую сторону, затем по правую сторону, затем складывает или умножает их.

Примеры

В следующих примерах показаны объявления перечисления.

Значение 0 связано с по умолчанию. Для идентификатора явно задано значение 0. Оставшимся идентификаторам по умолчанию присваиваются значения от 1 до 5.

В этом примере значение из набора присваивается переменной .

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

Чтобы явно присвоить целочисленное значение переменной перечисляемого типа данных, используйте следующее приведение типа.

Это приведение рекомендовано к использованию в С, но не является обязательным.

Это объявление также можно указать как

или как

Пример, в котором используются эти переменные, может выглядеть следующим образом.

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

В заявлениях if

Поскольку перечисления являются константами, вам часто приходится сравнивать переменную, указывающую на константу перечисления, с возможными константами в типе перечисления:

Level level = ...  //assign some Level constant to it

if( level == Level.HIGH) {

} else if( level == Level.MEDIUM) {

} else if( level == Level.LOW) {

}

Этот код сравнивает переменную уровня с каждой из возможных констант перечисления в перечислении уровня.

Если одно из значений встречается чаще, чем другие, проверка этого значения в первом операторе if приведет к лучшей производительности, так как выполняется меньше сравнений в среднем. Это не большая разница, если только сравнения не выполняются.

Перечисления без перечислителей

Visual Studio 2017 версии 15,3 и более поздних версий (доступно в и более поздних версиях): путем определения перечисления (regular или с ограниченной областью) с явным базовым типом и без перечислителей, вы можете использовать новый целочисленный тип, который не имеет неявного преобразования в любой другой тип. Используя этот тип вместо встроенного базового типа, можно исключить потенциальные ошибки для незначительных ошибок, вызванных случайными неявными преобразованиями.

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

Тест

Задание №1

Напишите перечисление со следующими перечислителями: , , , и .

Ответ №1

enum MonsterType
{
MONSTER_OGRE,
MONSTER_GOBLIN,
MONSTER_SKELETON,
MONSTER_ORC,
MONSTER_TROLL
};

1
2
3
4
5
6
7
8

enumMonsterType

{

MONSTER_OGRE,

MONSTER_GOBLIN,

MONSTER_SKELETON,

MONSTER_ORC,

MONSTER_TROLL

};

Задание №2

Объявите переменную перечисляемого типа, который вы определили в задании №1, и присвойте ей значение .

Ответ №2

MonsterType eMonsterType = MONSTER_OGRE;

1 MonsterType eMonsterType=MONSTER_OGRE;

Задание №3

Правда или ложь:

Перечислителям можно:

   присваивать целочисленные значения;

   не присваивать значения;

   явно присваивать значения типа с плавающей точкой;

   присваивать значения предыдущих перечислителей (например, ).

Перечислители могут быть:

   отрицательными;

   не уникальными.

Ответ №3

Перечислителям можно:

   Правда.

   Правда. Перечислителю без значения будет неявно присвоено целочисленное значение предыдущего перечислителя +1. Если предыдущего перечислителя нет, то тогда присвоится значение .

   Ложь.

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

Перечислители могут быть:

   Правда.

   Правда.

Fields

Вы можете добавить поля в перечисление. Таким образом, каждое значение константы enum получает их. Значения полей должны быть предоставлены конструктору перечисления при определении констант:

public enum Level {
    HIGH(3),  //calls constructor with value 3
    MEDIUM(2),  //calls constructor with value 2
    LOW (1)   //calls constructor with value 1
    ; // semicolon needed when fields / methods follow


    private final int levelCode;

    private Level(int levelCode) {
        this.levelCode = levelCode;
    }
}

Конструктор enum должен быть либо закрытым, либо областью действия пакета (по умолчанию). Вы не можете использовать публичные или защищенные.

Правила именования идентификаторов

Напоминаем, что имя переменной (или функции, типа или другого типа элемента) называется идентификатором. C++ дает вам большую гибкость для именования идентификаторов по вашему желанию. Однако есть несколько правил, которые при именовании идентификаторов необходимо соблюдать:

  • идентификатор не может быть ключевым словом (ключевые слова зарезервированы);
  • идентификатор может состоять только из букв (нижнего или верхнего регистра), цифр и символов подчеркивания. Это означает, что имя не может содержать другие символы (кроме подчеркивания) или пробельные символы (пробелы или табуляции);
  • идентификатор должен начинаться с буквы (нижний или верхний регистр) или символа подчеркивания, он не может начинаться с цифры;
  • C++ чувствителен к регистру и, таким образом, различает строчные и прописные буквы ( отличается от и от ).

Использование оператора индексации с константными объектами класса

В вышеприведенном примере метод operator[]() не является константным, и мы можем использовать этот метод для изменения данных неконстантных объектов. Однако, что произойдет, если наш объект класса IntArray будет const? В этом случае мы не сможем вызывать неконстантный operator[](), так как он изменяет значения объекта (детально о классах и const читайте в материалах урока №123).

Хорошей новостью является то, что мы можем определить отдельно неконстантную и константную версии operator[](). Неконстантная версия будет использоваться с неконстантными объектами, а версия const — с объектами const:

#include <iostream>

class IntArray
{
private:
int m_array = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; // указываем начальные значения

public:
int& operator[] (const int index);
const int& operator[] (const int index) const;
};

int& IntArray::operator[] (const int index) // для неконстантных объектов: может использоваться как для присваивания значений элементам, так и для их просмотра
{
return m_array;
}

const int& IntArray::operator[] (const int index) const // для константных объектов: используется только для просмотра (вывода) элементов массива
{
return m_array;
}

int main()
{
IntArray array;
array = 5; // хорошо: вызывается неконстантная версия operator[]()
std::cout << array;

const IntArray carray;
carray = 5; // ошибка компиляции: вызывается константная версия operator[](), которая возвращает константную ссылку. Выполнять операцию присваивания нельзя
std::cout << carray;

return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#include <iostream>
 

classIntArray

{

private

intm_array10={,1,2,3,4,5,6,7,8,9};// указываем начальные значения

public

int&operator(constintindex);

constint&operator(constintindex)const;

};

int&IntArray::operator(constintindex)// для неконстантных объектов: может использоваться как для присваивания значений элементам, так и для их просмотра

{

returnm_arrayindex;

}

constint&IntArray::operator(constintindex)const// для константных объектов: используется только для просмотра (вывода) элементов массива

{

returnm_arrayindex;

}

intmain()

{

IntArray array;

array4=5;// хорошо: вызывается неконстантная версия operator[]()

std::cout<<array4;

constIntArray carray;

carray4=5;// ошибка компиляции: вызывается константная версия operator[](), которая возвращает константную ссылку. Выполнять операцию присваивания нельзя

std::cout<<carray4;

return;

}

Строку нужно закомментировать и программа скомпилируется (это проверка на изменение данных константных объектов — изменять данные нельзя, можно только выводить).

Итератор для перечисления

И напоследок сделаем итератор для перечислений, с помощью которых можно использовать

range-based

цикл

for

.

#include <iostream>

enum class ColorTypes
{
    Blue,
    Red,
    Green,
    Purple,
    First=ColorTypes::Blue,   // участник перечисления для первого элемента
    Last=ColorTypes::Purple // участник перечисления для последнего элемента
};

ColorTypes operator++(ColorTypes& x)
{
    // std::underlying_type преобразовывает тип ColorTypes в целочисленный тип, под которым данный enum был объявлен
    return x = static_cast<ColorTypes>(std::underlying_type<ColorTypes>::type(x) + 1);
}

ColorTypes operator*(ColorTypes c)
{
    return c;
}

ColorTypes begin(ColorTypes r)
{
    return ColorTypes::First;
}

ColorTypes end(ColorTypes r)
{
    ColorTypes l=ColorTypes::Last;
    return ++l;
}

int main(int argc, char *argv[])
{
    // Используем круглые скобки для инстанцирования перечисления
    for(const auto& c : ColorTypes())
    {
        std::cout << static_cast<int>(c) << std::endl;
    }

    return 0;
}

Реализация интерфейса

Enum может реализовать интерфейс, если чувствуете, что это имеет смысл в вашей ситуации:

public enum EnumImplementingInterface implements MyInterface {
    FIRST("First Value"), SECOND("Second Value");


    private String description = null;

    private EnumImplementingInterface(String desc){
        this.description = desc;
    }

    @Override
    public String getDescription() {
        return this.description;
    }
}

Это метод getDescription(), который приходит из интерфейса MyInterface.

Реализация интерфейса с Enum может использоваться для реализации набора различных констант Comparator, которые применяются для сортировки коллекций объектов.

Небольшой тест

Вопрос 1

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

Ответ

Правильно.

Ответ

Неправильно – имена переменных не должны начинаться с подчеркивания.

Ответ

Неправильно — имена переменных должны начинаться со строчной буквы.

Ответ

Недопустимо – имена переменных не могут содержать пробелов.

Ответ

Неправильно – имена переменных должны начинаться со строчной буквы.

Ответ

Недопустимо – – это ключевое слово.

Ответ

Правильно.

Ответ

Недопустимо – имена переменных не могут начинаться с цифры.

Ответ

Правильно.

Обработка перечислений

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

#include <iostream>

// Определяем новый перечисляемый тип Animals
enum Animals
{
ANIMAL_PIG = -4,
ANIMAL_LION, // присваивается -3
ANIMAL_CAT, // присваивается -2
ANIMAL_HORSE = 6,
ANIMAL_ZEBRA = 6, // имеет то же значение, что и ANIMAL_HORSE
ANIMAL_COW // присваивается 7
};

int main()
{
int mypet = ANIMAL_PIG;
std::cout << ANIMAL_HORSE; // конвертируется в int, а затем выводится на экран

return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

#include <iostream>
 
// Определяем новый перечисляемый тип Animals

enumAnimals

{

ANIMAL_PIG=-4,

ANIMAL_LION,// присваивается -3

ANIMAL_CAT,// присваивается -2

ANIMAL_HORSE=6,

ANIMAL_ZEBRA=6,// имеет то же значение, что и ANIMAL_HORSE

ANIMAL_COW// присваивается 7

};

intmain()

{

intmypet=ANIMAL_PIG;

std::cout<<ANIMAL_HORSE;// конвертируется в int, а затем выводится на экран

return;

}

Результат выполнения программы:

Компилятор не будет неявно конвертировать целочисленное значение в значение перечислителя. Следующее вызовет ошибку компиляции:

Animals animal = 7; // приведет к ошибке компиляции

1 Animals animal=7;// приведет к ошибке компиляции

Тем не менее, вы можете сделать подобное с помощью :

Colors color = static_cast<Colors>(5); // но делать так не рекомендуется

1 Colors color=static_cast<Colors>(5);// но делать так не рекомендуется

Компилятор также не позволит вам вводить перечислители через std::cin:

#include <iostream>

enum Colors
{
COLOR_PURPLE, // присваивается 0
COLOR_GRAY, // присваивается 1
COLOR_BLUE, // присваивается 2
COLOR_GREEN, // присваивается 3
COLOR_BROWN, // присваивается 4
COLOR_PINK, // присваивается 5
COLOR_YELLOW, // присваивается 6
COLOR_MAGENTA // присваивается 7
};

int main()
{
Colors color;
std::cin >> color; // приведет к ошибке компиляции

return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

#include <iostream>
 

enumColors

{

COLOR_PURPLE,// присваивается 0

COLOR_GRAY,// присваивается 1

COLOR_BLUE,// присваивается 2

COLOR_GREEN,// присваивается 3

COLOR_BROWN,// присваивается 4

COLOR_PINK,// присваивается 5

COLOR_YELLOW,// присваивается 6

COLOR_MAGENTA// присваивается 7

};

intmain()

{

Colors color;

std::cin>>color;// приведет к ошибке компиляции

return;

}

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

int inputColor;
std::cin >> inputColor;

Colors color = static_cast<Colors>(inputColor);

1
2
3
4

intinputColor;

std::cin>>inputColor;

Colors color=static_cast<Colors>(inputColor);

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

Animals animal = COLOR_BLUE; // приведет к ошибке компиляции

1 Animals animal=COLOR_BLUE;// приведет к ошибке компиляции

Как и в случае с константами, перечисления отображаются в отладчике, что делает их еще более полезными.

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

Объявление происходит следующим образом:

char c;
short int si; // допустимо
short s; // предпочтительнее
int i;
long int li; // допустимо
long l; // предпочтительнее
long long int lli; // допустимо
long long ll; // предпочтительнее

1
2
3
4
5
6
7
8

charc;

shortintsi;// допустимо

shorts;// предпочтительнее

inti;

longintli;// допустимо

longl;// предпочтительнее

longlongintlli;// допустимо

longlongll;// предпочтительнее

В то время как полные названия ,  и могут использоваться, их сокращенные версии (без ) более предпочтительны для использования. К тому же постоянное добавление затрудняет чтение кода (легко перепутать с именем переменной).

Типы перечислений enum

Тип перечисление (enum) представляет собой набор символьных имен, связанных с уникальными целочисленными значениями. Для объявления этого типа используется оператор enum. После оператора enum указывается имя создаваемого типа. Через двоеточие можно указать тип констант перечисления (должен быть целочисленным). Если не указывать тип явно, то будет использован int. После этого приводится список символьных констант через запятую. Пример типа перечисления:

enum TypeOS
{
    Windows, Linux, MacOS, Android
}

Каждому элементу перечисления присваивается целочисленное значение, в примере выше, эти значения начинаются с нуля и, далее, увеличиваются на единицу. Можно явно задать значения элементам перечисления. Для этого C# предоставляет два варианта: первый – это задание численного значения первому элементу, при этом все остальные, по очереди, принимают значения на единицу больше:

enum TypeOS 
{
    Windows = 1,
    Linux,
    MacOS,
    Android
}

Второй вариант предполагает явное задание численных значений каждому элементу перечисления индивидуально:

enum TypeOS 
{
    Windows = 1,
    Linux = 3,
    MacOS = 5,
    Android = 7
}

Небольшой тест

Вопрос 1

Проверьте следующие программы и укажите, что они выводят, или будут ли они не компилироваться.

1а)

Ответ

Эта программа печатает число 16.

1b)

Ответ

Эта программа не компилируется. Вложенные функции не допускаются.

1c)

Ответ

Эта программа компилируется, но ничего не выводит. Значения, возвращаемые функциями, ни для чего не используются (и, таким образом, отбрасываются).

1d)

Ответ

Эта программа печатает буквы A и B в отдельных строках.

1e)

Ответ

Эта программа не компилируется. Функция возвращает , которое пытается отправить в . Это приведет к ошибке компиляции.

1f)

Ответ

Эта программа напечатает 5 дважды (в отдельных строках). Оба раза, когда вызывается функция , возвращается значение 5. Когда выполняется инструкция , функция немедленно завершается, поэтому инструкция никогда не выполняется.

1g)

Ответ

Эта программа не будет компилироваться, потому что функция имеет недопустимое имя. Мы говорили о правилах именования в уроке «1.7 – Ключевые слова и именование идентификаторов».

1h) Чуть сложнее.

Ответ

Эта программа будет скомпилирована, но функция не будет вызвана, потому что при вызове функции отсутствуют круглые скобки. То, что на самом деле будет выведено, зависит от компилятора.

Вопрос 2

Что означает «DRY» и почему это полезно?

Ответ

DRY означает «Don’t Repeat Yourself» (не повторяйся). Это практика, которая включает в себя написание кода таким образом, чтобы минимизировать избыточность. Это делает ваши программы более краткими, менее подверженными ошибкам и более удобными для поддержки.

Рейтинг
( Пока оценок нет )
Понравилась статья? Поделиться с друзьями:
Все про сервера
Добавить комментарий

;-) :| :x :twisted: :smile: :shock: :sad: :roll: :razz: :oops: :o :mrgreen: :lol: :idea: :grin: :evil: :cry: :cool: :arrow: :???: :?: :!:

Adblock
detector