Beginner's Guide: An Introduction to C++ Variables and Data Types

1. Why Are Data Types Needed?¶

Imagine we need to record “Xiaoming’s” age, height, and gender. Simply writing “Xiaoming 20 years old 1.75 meters male” won’t work because the computer needs to clearly know: “20” is age (integer), “1.75” is height (decimal), and “male” is a character (single letter). Data types act like “labels” for data, telling the computer: “This is an integer, that’s a decimal, and this is a character.” This helps the computer determine how to store and process the data.

2. What Are Variables?¶

A variable can be thought of as a “container” for storing data. It has two core elements:
- Name: For example, age or height (must follow C++ naming rules: cannot start with a number, cannot be a keyword).
- Data type: Determines what kinds of data the variable can store (e.g., integers, decimals) and how much memory it occupies.

Example:

int age;  // Declare an int-type variable "age" (uninitialized, value unknown)
age = 20; // Assign value 20 to "age" (now age is the integer 20)

3. Common C++ Data Types¶

C++ provides various basic data types, categorized by functionality:

3.1 Integer Types (int Series)¶

For storing integers without decimal parts. Common types and characteristics:
- int: The most commonly used integer type, typically occupies 4 bytes (range: ~-2.1 billion to 2.1 billion).

  int score = 95;   // Store the integer 95
  int negative = -30; // Negative numbers are allowed

short: Short integer, occupies 2 bytes (smaller range, suitable for small integers).
long: Long integer, occupies 4 or 8 bytes (larger range, suitable for big integers; use L suffix for literals).

  long big_num = 1000000000L; // Add L to denote a long integer literal

long long: Super long integer, occupies 8 bytes (largest range, suitable for extremely large integers).

  long long max_num = 9223372036854775807LL; // Largest integer

3.2 Floating-Point Types (Decimal Types)¶

For storing numbers with decimal points, differing in precision and range:
- float: Single-precision floating-point, occupies 4 bytes (limited precision: ~6-7 decimal places).

  float pi = 3.14f; // Add f to denote a float literal

double: Double-precision floating-point, occupies 8 bytes (higher precision: ~15-17 decimal places) and a larger value range.

  double e = 2.718281828459045; // Double-precision, more accurate

3.3 Character Type (char)¶

Stores single characters (e.g., letters, numbers, symbols), occupies 1 byte (essentially an ASCII code).

char grade = 'A'; // Store the character 'A' (ASCII code 65)
char symbol = '!'; // Store the symbol '!'
int ascii = grade; // The ASCII code of 'A' is 65, which can be stored in an int

3.4 Boolean Type (bool)¶

Has only two values: true (true) and false (false), used for conditional judgment results.

bool is_student = true;
bool has_pass = false;

4. Variable Declaration and Initialization¶

When declaring a variable, specify its type. You can initialize it directly during definition; uninitialized variables have random values, so avoid this!

Correct Practices:

// Define and initialize variables (recommended)
int age = 18;       // Declare and assign value 18
double height = 1.75;
char gender = 'M';
bool is_student = true;

// Declare first, then assign (note: unassigned values are random)
int score;
score = 90; // Valid after assignment

5. Variable Naming Rules¶

Allowed characters: Letters, numbers, and underscores.
Prohibited: Starting with a number (e.g., age123 is valid, 123age is invalid).
Cannot use C++ keywords: Such as int, if, for (reserved for syntax).
Case sensitivity: age and Age are distinct variables.
Meaningful names: Avoid vague names like a or b; use student_age or user_height for clarity.

6. Complete Example: Using Variables and Data Types¶

#include <iostream> // Include input/output header
using namespace std; // Avoid repeating "std::"

int main() {
    // Define variables of different types
    int age = 20;
    double height = 1.75;
    char gender = 'M';
    bool is_student = true;

    // Output variable values
    cout << "Age: " << age << endl;
    cout << "Height: " << height << " meters" << endl;
    cout << "Gender: " << gender << endl;
    cout << "Is Student: " << (is_student ? "Yes" : "No") << endl;

    return 0;
}

Output:

Age: 20
Height: 1.75 meters
Gender: M
Is Student: Yes

7. Summary¶

Variables and data types are the foundation of C++:
- Data types tell the computer the “category” of data (integer/decimal/character) and how to process it.
- Variables are containers for data, requiring a type and a name.
- Choose the right data type: use int for small integers, double for decimals, char for characters, and bool for booleans.

Practice defining variables of different types and outputting their values to master this. When in doubt, ask: “What type should this data use? Is the variable name valid?” With practice, you’ll quickly become proficient.