Переменные и типы данных в C++

C++C++Beginner
Практиковаться сейчас

💡 Этот учебник переведен с английского с помощью ИИ. Чтобы просмотреть оригинал, вы можете перейти на английский оригинал

Введение

В этом практическом занятии (лабораторной работе) вы научитесь работать с переменными и типами данных в C++. Вы исследуете различные размеры целочисленных переменных, инициализируете переменные типа float и double, объявляете переменные типа char и строковые переменные, выполняете приведение типов, определяете константы, используете булевы переменные и проверяете размер памяти различных типов данных. Кроме того, вы научитесь обрабатывать ситуации целочисленного переполнения. Этот практический опыт даст вам прочный фундамент для управления данными в своих проектах на C++.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL cpp(("C++")) -.-> cpp/BasicsGroup(["Basics"]) cpp(("C++")) -.-> cpp/ControlFlowGroup(["Control Flow"]) cpp(("C++")) -.-> cpp/IOandFileHandlingGroup(["I/O and File Handling"]) cpp(("C++")) -.-> cpp/StandardLibraryGroup(["Standard Library"]) cpp/BasicsGroup -.-> cpp/variables("Variables") cpp/BasicsGroup -.-> cpp/data_types("Data Types") cpp/BasicsGroup -.-> cpp/operators("Operators") cpp/BasicsGroup -.-> cpp/booleans("Booleans") cpp/BasicsGroup -.-> cpp/strings("Strings") cpp/ControlFlowGroup -.-> cpp/conditions("Conditions") cpp/ControlFlowGroup -.-> cpp/if_else("If...Else") cpp/IOandFileHandlingGroup -.-> cpp/output("Output") cpp/StandardLibraryGroup -.-> cpp/string_manipulation("String Manipulation") subgraph Lab Skills cpp/variables -.-> lab-446078{{"Переменные и типы данных в C++"}} cpp/data_types -.-> lab-446078{{"Переменные и типы данных в C++"}} cpp/operators -.-> lab-446078{{"Переменные и типы данных в C++"}} cpp/booleans -.-> lab-446078{{"Переменные и типы данных в C++"}} cpp/strings -.-> lab-446078{{"Переменные и типы данных в C++"}} cpp/conditions -.-> lab-446078{{"Переменные и типы данных в C++"}} cpp/if_else -.-> lab-446078{{"Переменные и типы данных в C++"}} cpp/output -.-> lab-446078{{"Переменные и типы данных в C++"}} cpp/string_manipulation -.-> lab-446078{{"Переменные и типы данных в C++"}} end

Объявление целочисленных переменных различных размеров (short, int, long)

На этом этапе вы узнаете о различных типах целочисленных переменных в C++ и о том, как объявлять переменные с разным размером памяти. C++ предоставляет несколько целочисленных типов, чтобы помочь вам выбрать наиболее подходящее хранение для ваших данных.

Откройте WebIDE и создайте новый файл с именем integer_variables.cpp в директории ~/project:

touch ~/project/integer_variables.cpp

Добавьте следующий код в файл integer_variables.cpp:

#include <iostream>

int main() {
    // Declaring short integer (typically 2 bytes)
    short smallNumber = 32767;

    // Declaring standard integer (typically 4 bytes)
    int regularNumber = 2147483647;

    // Declaring long integer (typically 4 or 8 bytes)
    long largeNumber = 9223372036854775807L;

    // Printing the values of different integer types
    std::cout << "Short Integer: " << smallNumber << std::endl;
    std::cout << "Regular Integer: " << regularNumber << std::endl;
    std::cout << "Long Integer: " << largeNumber << std::endl;

    return 0;
}

Разберём типы целых чисел:

  1. short:

    • Наименьший целочисленный тип
    • Обычно использует 2 байта памяти
    • Диапазон: -32 768 до 32 767
  2. int:

    • Стандартный целочисленный тип
    • Обычно использует 4 байта памяти
    • Диапазон: -2 147 483 648 до 2 147 483 647
  3. long:

    • Более крупный целочисленный тип
    • Может быть 4 или 8 байтами в зависимости от системы
    • Диапазон: -9 223 372 036 854 775 808 до 9 223 372 036 854 775 807

Скомпилируйте и запустите программу:

g++ integer_variables.cpp -o integer_variables
./integer_variables

Пример вывода:

Short Integer: 32767
Regular Integer: 2147483647
Long Integer: 9223372036854775807

Основные моменты, которые необходимо запомнить:

  • Выбирайте целочисленный тип на основе диапазона значений, которые вы хотите хранить
  • Суффикс L для длинных целых чисел гарантирует правильную интерпретацию типа
  • Разные системы могут иметь несколько разные размеры памяти для этих типов

Понимание целочисленных типов и их диапазонов является фундаментом программирования на C++. Эти типы обеспечивают различное выделение памяти для эффективного хранения различных диапазонов целых чисел. Давайте визуализируем, как эти типы вписываются в более широкую систему типов C++:

graph LR A[C++ Data Types] --> B[Fundamental Types] A --> C[Derived Types] B --> D[Integer Types] B --> E[Floating-Point Types] B --> F[Character Types] B --> G[Boolean] D --> D1[short] D --> D2[int] D --> D3[long] D --> D4[long long] E --> E1[float] E --> E2[double] E --> E3[long double] F --> F1[char] F --> F2[wchar_t] C --> H[Arrays] C --> I[Pointers] C --> J[References] C --> K[std::string] style A fill:#f9f,stroke:#333,stroke-width:2px style B fill:#bbf,stroke:#333 style C fill:#bbf,stroke:#333

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

Инициализация переменных типа float и double с десятичными точками

На этом этапе вы узнаете о переменных с плавающей точкой в C++, а именно о типах float и double, которые позволяют работать с десятичными числами. Эти типы важны для представления чисел с дробной частью.

Откройте WebIDE и создайте новый файл с именем floating_point.cpp в директории ~/project:

touch ~/project/floating_point.cpp

Добавьте следующий код в файл floating_point.cpp:

#include <iostream>
#include <iomanip>

int main() {
    // Declaring and initializing float variables
    float smallDecimal = 3.14f;  // 'f' suffix indicates float
    float scientificNotation = 2.5e3f;  // 2.5 × 10^3 = 2500.0

    // Declaring and initializing double variables
    double preciseDecimal = 3.14159265359;
    double largeDecimal = 1.23456789e10;  // 12,345,678,900.0

    // Setting precision for decimal output
    std::cout << std::fixed << std::setprecision(4);

    // Printing float values
    std::cout << "Float Values:" << std::endl;
    std::cout << "Small Decimal: " << smallDecimal << std::endl;
    std::cout << "Scientific Notation: " << scientificNotation << std::endl;

    // Printing double values
    std::cout << "\nDouble Values:" << std::endl;
    std::cout << "Precise Decimal: " << preciseDecimal << std::endl;
    std::cout << "Large Decimal: " << largeDecimal << std::endl;

    return 0;
}

Разберём типы с плавающей точкой:

  1. float:

    • Тип с одинарной точностью (single-precision floating-point type)
    • Обычно использует 4 байта памяти
    • Менее точный, подходит для простых десятичных вычислений
    • Используйте суффикс 'f' при инициализации
  2. double:

    • Тип с двойной точностью (double-precision floating-point type)
    • Обычно использует 8 байта памяти
    • Более точный, предпочтителен для большинства десятичных вычислений
    • Может представлять большие и более точные десятичные числа

Скомпилируйте и запустите программу:

g++ floating_point.cpp -o floating_point
./floating_point

Пример вывода:

Float Values:
Small Decimal: 3.1416
Scientific Notation: 2500.0000

Double Values:
Precise Decimal: 3.1416
Large Decimal: 12345678900.0000

Основные моменты, которые необходимо запомнить:

  • Используйте float для меньших и менее точных десятичных чисел
  • Используйте double для более точных вычислений
  • Суффикс 'f' важен для литералов типа float
  • Научная нотация позволяет представлять очень большие или маленькие числа
  • std::fixed и std::setprecision() помогают контролировать вывод десятичных чисел

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

На этом этапе вы узнаете о символьных переменных в C++, которые используются для хранения отдельных символов и объявляются с использованием одинарных кавычек. Символы - это фундаментальные типы данных, представляющие отдельные буквы, цифры или символы.

Откройте WebIDE и создайте новый файл с именем character_variables.cpp в директории ~/project:

touch ~/project/character_variables.cpp

Добавьте следующий код в файл character_variables.cpp:

#include <iostream>

int main() {
    // Declaring and initializing character variables
    char letter = 'A';
    char number = '7';
    char symbol = '$';

    // Printing character values
    std::cout << "Letter: " << letter << std::endl;
    std::cout << "Number: " << number << std::endl;
    std::cout << "Symbol: " << symbol << std::endl;

    // Demonstrating character arithmetic
    char nextLetter = letter + 1;
    std::cout << "Next Letter: " << nextLetter << std::endl;

    // ASCII value of characters
    std::cout << "ASCII value of 'A': " << (int)letter << std::endl;

    return 0;
}

Разберём символьные переменные:

  1. Объявление:

    • Используйте ключевое слово char
    • Всегда инициализируйте с использованием одинарных кавычек ''
    • Может хранить один символ
  2. Типы символов:

    • Буквы: 'A', 'b', 'Z'
    • Цифры: '0', '7', '9'
    • Символы: '$', '@', '#'
  3. Арифметические операции с символами:

    • Символы можно манипулировать с использованием целочисленных операций
    • Каждый символ имеет соответствующее числовое значение в таблице ASCII

Скомпилируйте и запустите программу:

g++ character_variables.cpp -o character_variables
./character_variables

Пример вывода:

Letter: A
Number: 7
Symbol: $
Next Letter: B
ASCII value of 'A': 65

Основные моменты, которые необходимо запомнить:

  • Используйте одинарные кавычки '' для символьных литералов
  • Символы хранятся как числовые значения (в соответствии с таблицей ASCII)
  • Вы можете выполнять арифметические операции с символами
  • Каждый символ занимает 1 байт памяти

Создание строковых переменных с использованием std::string

На этом этапе вы узнаете, как создавать и манипулировать строковыми переменными с использованием класса std::string в C++. Строки представляют собой последовательности символов, которые позволяют более легко работать с текстом по сравнению с символьными массивами.

Откройте WebIDE и создайте новый файл с именем string_variables.cpp в директории ~/project:

touch ~/project/string_variables.cpp

Добавьте следующий код в файл string_variables.cpp:

#include <iostream>
#include <string>

int main() {
    // Declaring and initializing string variables
    std::string greeting = "Hello, World!";
    std::string name = "John Doe";
    std::string empty_string;

    // Printing string variables
    std::cout << "Greeting: " << greeting << std::endl;
    std::cout << "Name: " << name << std::endl;

    // String concatenation
    std::string welcome = greeting + " Welcome, " + name;
    std::cout << "Welcome Message: " << welcome << std::endl;

    // String length
    std::cout << "Greeting length: " << greeting.length() << std::endl;

    // Accessing individual characters
    std::cout << "First character of name: " << name[0] << std::endl;

    // Modifying strings
    name = "Jane Smith";
    std::cout << "Updated Name: " << name << std::endl;

    return 0;
}

Разберём операции с строками:

  1. Объявление:

    • Используйте #include <string>, чтобы получить доступ к функционалу работы со строками
    • Объявляйте с использованием ключевого слова std::string
    • Можно инициализировать текстом или оставить пустой
  2. Операции с строками:

    • Конкатенация с использованием оператора +
    • Получение длины с помощью метода .length()
    • Доступ к символам с использованием индекса []

Скомпилируйте и запустите программу:

g++ string_variables.cpp -o string_variables
./string_variables

Пример вывода:

Greeting: Hello, World!
Name: John Doe
Welcome Message: Hello, World! Welcome, John Doe
Greeting length: 13
First character of name: J
Updated Name: Jane Smith

Основные моменты, которые необходимо запомнить:

  • std::string более гибок, чем символьные массивы
  • Строки можно легко модифицировать и манипулировать
  • Используйте .length(), чтобы получить размер строки
  • Строки можно конкатенировать с использованием оператора +

Преобразование между разными числовыми типами с использованием приведения типов

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

Откройте WebIDE и создайте новый файл с именем type_casting.cpp в директории ~/project:

touch ~/project/type_casting.cpp

Добавьте следующий код в файл type_casting.cpp:

#include <iostream>

int main() {
    // Implicit type casting (automatic conversion)
    int intValue = 10;
    double doubleValue = intValue;  // Automatically converts int to double
    std::cout << "Implicit Conversion (int to double): " << doubleValue << std::endl;

    // Explicit type casting (manual conversion)
    double pi = 3.14159;
    int truncatedPi = (int)pi;  // C-style cast, truncates decimal part
    std::cout << "Explicit Conversion (double to int): " << truncatedPi << std::endl;

    // Static cast for type conversion
    float floatValue = 7.5f;
    int roundedValue = static_cast<int>(floatValue);
    std::cout << "Static Cast (float to int): " << roundedValue << std::endl;

    // Conversion between numeric types with potential data loss
    long largeNumber = 1000000;
    short smallNumber = static_cast<short>(largeNumber);
    std::cout << "Large to Small Type Conversion: " << smallNumber << std::endl;

    // Mixing different numeric types in calculations
    int a = 5;
    double b = 2.5;
    double result = a + b;  // Implicit conversion of int to double
    std::cout << "Mixed Type Calculation: " << result << std::endl;

    return 0;
}

Разберём приведение типов:

  1. Неявное приведение типов (Implicit Casting):

    • Автоматическое преобразование между совместимыми типами
    • Происходит без вмешательства программиста
    • Как правило, безопасно при преобразовании в более широкий тип
  2. Явное приведение типов (Explicit Casting):

    • Ручное преобразование типов
    • Использует синтаксис static_cast<>() или C-стильный (type)
    • Может привести к потере данных или неожиданным результатам

Скомпилируйте и запустите программу:

g++ type_casting.cpp -o type_casting
./type_casting

Пример вывода:

Implicit Conversion (int to double): 10
Explicit Conversion (double to int): 3
Static Cast (float to int): 7
Large to Small Type Conversion: 16960
Mixed Type Calculation: 7.5

Основные моменты, которые необходимо запомнить:

  • Будьте осторожны при приведении к более узким типам
  • Используйте static_cast<>() для более безопасных и явных преобразований
  • Понимайте возможную потерю данных при преобразованиях
  • Неявные преобразования могут происходить автоматически в вычислениях

Определение констант с использованием ключевого слова const

На этом этапе вы узнаете, как определять константы в C++ с использованием ключевого слова const. Константы - это значения, которые не могут быть изменены после инициализации. Они позволяют создавать неизменяемые переменные, защищающие данные от случайных модификаций.

Откройте WebIDE и создайте новый файл с именем constants.cpp в директории ~/project:

touch ~/project/constants.cpp

Добавьте следующий код в файл constants.cpp:

#include <iostream>

int main() {
    // Defining constants with const keyword
    const int MAX_USERS = 100;
    const double PI = 3.14159;
    const char GRADE_SEPARATOR = '-';

    // Demonstrating constant usage
    std::cout << "Maximum Users: " << MAX_USERS << std::endl;
    std::cout << "Value of PI: " << PI << std::endl;
    std::cout << "Grade Separator: " << GRADE_SEPARATOR << std::endl;

    // Naming convention: constants typically use UPPERCASE
    const int DAYS_IN_WEEK = 7;
    const std::string WELCOME_MESSAGE = "Welcome to C++ Programming!";

    std::cout << "Days in a Week: " << DAYS_IN_WEEK << std::endl;
    std::cout << "Welcome Message: " << WELCOME_MESSAGE << std::endl;

    // Attempting to modify a constant (will cause a compilation error)
    // Uncomment the next line to see the error
    // MAX_USERS = 200;  // This would cause a compile-time error

    return 0;
}

Разберём константы:

  1. Объявление:

    • Используйте ключевое слово const перед типом
    • Должен быть инициализирован при объявлении
    • Не может быть изменен после инициализации
  2. Лучшие практики:

    • Используйте заглавные буквы для имен констант
    • Работает со всеми типами данных
    • Помогает предотвратить случайные модификации

Скомпилируйте и запустите программу:

g++ constants.cpp -o constants
./constants

Пример вывода:

Maximum Users: 100
Value of PI: 3.14159
Grade Separator: -
Days in a Week: 7
Welcome Message: Welcome to C++ Programming!

Основные моменты, которые необходимо запомнить:

  • const создает неизменяемую переменную
  • Константы должны быть инициализированы при объявлении
  • Помогает сделать код более читаемым и безопасным
  • Предотвращает непреднамеренные изменения важных значений

Использование булевых переменных для условий "истина"/"ложь"

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

Откройте WebIDE и создайте новый файл с именем boolean_variables.cpp в директории ~/project:

touch ~/project/boolean_variables.cpp
#include <iostream>

int main() {
    // Declaring boolean variables
    bool isStudent = true;
    bool hasPassedExam = false;

    // Printing boolean values
    std::cout << "Is Student: " << std::boolalpha << isStudent << std::endl;
    std::cout << "Passed Exam: " << hasPassedExam << std::endl;

    // Comparison operations that result in boolean values
    int age = 20;
    bool isAdult = (age >= 18);
    std::cout << "Is Adult: " << isAdult << std::endl;

    // Logical operations
    bool hasScholarship = true;
    bool canEnroll = isStudent && isAdult;
    std::cout << "Can Enroll: " << canEnroll << std::endl;

    // Negation
    bool isUnemployed =!hasPassedExam;
    std::cout << "Is Unemployed: " << isUnemployed << std::endl;

    // Conditional statement using boolean
    if (isStudent && hasPassedExam) {
        std::cout << "Congratulations! You can proceed to the next level." << std::endl;
    } else {
        std::cout << "You need to improve your academic performance." << std::endl;
    }

    return 0;
}

Разберём булевые переменные:

  1. Объявление:

    • Используйте ключевое слово bool
    • Может быть только true (истина) или false (ложь)
    • Полезно для условной логики
  2. Операции:

    • Операторы сравнения дают булевы результаты
    • Логическое И &&
    • Логическое ИЛИ ||
    • Отрицание !

Скомпилируйте и запустите программу:

g++ boolean_variables.cpp -o boolean_variables
./boolean_variables

Пример вывода:

Is Student: true
Passed Exam: false
Is Adult: true
Can Enroll: true
Is Unemployed: true
You need to improve your academic performance.

Основные моменты, которые необходимо запомнить:

  • Булевы переменные представляют условия "истина"/"ложь"
  • Используются в сравнениях и логических операциях
  • Необходимы для принятия решений в программах
  • std::boolalpha выводит "true"/"false" вместо 1/0

Проверка размера памяти различных типов данных с использованием sizeof()

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

Откройте WebIDE и создайте новый файл с именем sizeof_operator.cpp в директории ~/project:

touch ~/project/sizeof_operator.cpp
#include <iostream>

int main() {
    // Checking memory size of integer types
    std::cout << "Integer Types Memory Size:" << std::endl;
    std::cout << "short: " << sizeof(short) << " bytes" << std::endl;
    std::cout << "int: " << sizeof(int) << " bytes" << std::endl;
    std::cout << "long: " << sizeof(long) << " bytes" << std::endl;
    std::cout << "long long: " << sizeof(long long) << " bytes" << std::endl;

    // Checking memory size of floating-point types
    std::cout << "\nFloating-Point Types Memory Size:" << std::endl;
    std::cout << "float: " << sizeof(float) << " bytes" << std::endl;
    std::cout << "double: " << sizeof(double) << " bytes" << std::endl;
    std::cout << "long double: " << sizeof(long double) << " bytes" << std::endl;

    // Checking memory size of character and boolean types
    std::cout << "\nOther Types Memory Size:" << std::endl;
    std::cout << "char: " << sizeof(char) << " bytes" << std::endl;
    std::cout << "bool: " << sizeof(bool) << " bytes" << std::endl;

    // Checking memory size of specific variables
    int intVar = 42;
    double doubleVar = 3.14;
    char charVar = 'A';

    std::cout << "\nVariable Memory Size:" << std::endl;
    std::cout << "intVar: " << sizeof(intVar) << " bytes" << std::endl;
    std::cout << "doubleVar: " << sizeof(doubleVar) << " bytes" << std::endl;
    std::cout << "charVar: " << sizeof(charVar) << " bytes" << std::endl;

    return 0;
}

Разберём оператор sizeof():

  1. Назначение:

    • Определяет размер памяти типов данных
    • Возвращает размер в байтах
    • Полезно для понимания выделения памяти
  2. Использование:

    • Можно использовать с типами данных
    • Можно использовать с переменными
    • Помогает понять требования к памяти

Скомпилируйте и запустите программу:

g++ sizeof_operator.cpp -o sizeof_operator
./sizeof_operator

Пример вывода:

Integer Types Memory Size:
short: 2 bytes
int: 4 bytes
long: 8 bytes
long long: 8 bytes

Floating-Point Types Memory Size:
float: 4 bytes
double: 8 bytes
long double: 16 bytes

Other Types Memory Size:
char: 1 bytes
bool: 1 bytes

Variable Memory Size:
intVar: 4 bytes
doubleVar: 8 bytes
charVar: 1 bytes

Основные моменты, которые необходимо запомнить:

  • sizeof() возвращает размер памяти в байтах
  • Размеры памяти могут различаться на разных системах
  • Помогает понять требования к памяти для типов данных
  • Полезно для низкоуровневого управления памятью

Обработка ситуаций целочисленного переполнения

На этом этапе вы узнаете о целочисленном переполнении (integer overflow) — ситуации, которая возникает, когда результат вычисления превышает максимальное значение целочисленного типа. Понимание и предотвращение переполнения является важным аспектом написания надежных и устойчивых программ на C++.

Откройте WebIDE и создайте новый файл с именем integer_overflow.cpp в директории ~/project:

touch ~/project/integer_overflow.cpp
#include <iostream>
#include <limits>

int main() {
    // Demonstrating integer overflow with short int
    short smallInt = 32767;  // Maximum value for short
    std::cout << "Original Value: " << smallInt << std::endl;

    // Overflow occurs when incrementing beyond maximum
    smallInt++;
    std::cout << "After Overflow: " << smallInt << std::endl;

    // Using unsigned integers to prevent negative overflow
    unsigned int positiveOnly = 0;
    std::cout << "Unsigned Integer Start: " << positiveOnly << std::endl;

    // Decrementing unsigned integer causes wrap-around
    positiveOnly--;
    std::cout << "Unsigned Integer Wrap-around: " << positiveOnly << std::endl;

    // Checking integer limits
    std::cout << "\nInteger Type Limits:" << std::endl;
    std::cout << "Short Max: " << std::numeric_limits<short>::max() << std::endl;
    std::cout << "Short Min: " << std::numeric_limits<short>::min() << std::endl;

    // Safe increment method
    try {
        if (smallInt < std::numeric_limits<short>::max()) {
            smallInt++;
            std::cout << "Safe Increment: " << smallInt << std::endl;
        } else {
            std::cout << "Cannot increment further" << std::endl;
        }
    } catch (const std::overflow_error& e) {
        std::cout << "Overflow Error: " << e.what() << std::endl;
    }

    return 0;
}

Разберём целочисленное переполнение:

  1. Характеристики переполнения:

    • Возникает, когда значение превышает максимальное значение типа
    • Может привести к неожиданным результатам
    • Различное поведение для знаковых и беззнаковых типов
  2. Стратегии предотвращения:

    • Проверяйте границы значений перед вычислениями
    • Используйте более широкие целочисленные типы
    • Используйте беззнаковые типы для неотрицательных значений
    • Реализуйте проверку диапазона значений

Скомпилируйте и запустите программу:

g++ integer_overflow.cpp -o integer_overflow
./integer_overflow

Пример вывода:

Original Value: 32767
After Overflow: -32768
Unsigned Integer Start: 0
Unsigned Integer Wrap-around: 4294967295

Integer Type Limits:
Short Max: 32767
Short Min: -32768
Safe Increment: -32767

Основные моменты, которые необходимо запомнить:

  • Целочисленное переполнение может привести к неожиданным результатам
  • Разные типы имеют разное поведение при переполнении
  • Всегда проверяйте диапазон значений перед вычислениями
  • Используйте подходящие типы данных для своих вычислений

Резюме

В этом практическом занятии (lab) вы узнали о различных типах данных в C++ и о том, как работать с ними. Вы начали с объявления целочисленных переменных разных размеров, включая short, int и long, и изучили их соответствующие диапазоны значений. Затем вы инициализировали переменные с плавающей точкой, такие как float и double, с использованием десятичных точек. Вы также узнали, как объявлять и инициализировать символьные переменные с помощью одинарных кавычек, а также создавать строковые переменные с использованием класса std::string. Кроме того, вы изучили явное преобразование типов (type casting) для конвертации между разными числовыми типами, определили константы с использованием ключевого слова const и работали с булевыми переменными для представления условий "истина"/"ложь". Наконец, вы использовали оператор sizeof() для проверки размера памяти различных типов данных и научились обрабатывать ситуации целочисленного переполнения.