Basic Concept of Keywords

Keywords are reserved words in the C++ language that have special meanings. They define the syntax structure and basic operations of the language. Keywords cannot be used as identifier names (such as variable names, function names, etc.).

Key Features:

• Reserved: Keywords are specific to C++ and cannot be used for other purposes.
• Non-reusable: Keywords cannot be used as variable names or function names.
• Can be included: Keywords can be included in identifier names.
• Case-sensitive: C++ keywords are all lowercase.

Common Keyword Categories and Examples

1. Data Type Keywords

#include <iostream>
using namespace std;

int main() {
    // Basic data type keywords
    int age = 25;                    // int - Integer
    double salary = 5000.75;         // double - Double precision floating point
    float temperature = 36.6f;       // float - Single precision floating point
    char grade = 'A';                // char - Character
    bool isActive = true;            // bool - Boolean
    void* ptr = nullptr;             // void - No type
    
    // Type modifier keywords
    short smallNumber = 100;         // short - Short integer
    long bigNumber = 100000L;        // long - Long integer
    unsigned int positiveOnly = 255; // unsigned - Unsigned type
    const double PI = 3.14159;       // const - Constant
    
    cout << "Age: " << age << endl;
    cout << "Salary: " << salary << endl;
    cout << "Is Active: " << isActive << endl;
    
    return 0;
}

2. Control Flow Keywords

#include <iostream>
using namespace std;

int main() {
    // if-else conditional judgment
    int score = 85;
    if (score >= 90) {
        cout << "Excellent" << endl;
    } else if (score >= 60) {
        cout << "Pass" << endl;
    } else {
        cout << "Fail" << endl;
    }
    
    // switch-case multi-branch selection
    char operation = '+';
    switch (operation) {
        case '+':
            cout << "Performing addition" << endl;
            break;
        case '-':
            cout << "Performing subtraction" << endl;
            break;
        case '*':
            cout << "Performing multiplication" << endl;
            break;
        case '/':
            cout << "Performing division" << endl;
            break;
        default:
            cout << "Unknown operation" << endl;
    }
    
    // Loop control keywords
    // for loop
    for (int i = 0; i < 5; i++) {
        cout << "for loop iteration: " << i << endl;
    }
    
    // while loop
    int count = 0;
    while (count < 3) {
        cout << "while loop count: " << count << endl;
        count++;
    }
    
    // do-while loop
    int num = 5;
    do {
        cout << "do-while loop: " << num << endl;
        num--;
    } while (num > 0);
    
    // break and continue
    for (int i = 0; i < 10; i++) {
        if (i == 2) {
            continue;  // Skip the remaining part of this loop
        }
        if (i == 7) {
            break;     // Terminate the entire loop
        }
        cout << "i = " << i << endl;
    }
    
    return 0;
}

3. Function Related Keywords

#include <iostream>
using namespace std;

// return keyword - returns value from function
int add(int a, int b) {
    return a + b;  // return keyword returns result
}

// void keyword - indicates function does not return a value
void printMessage() {
    cout << "This is a function with no return value" << endl;
    // void function can have no return statement, or use return; (no return value)
}

// inline keyword - inline function
inline int multiply(int a, int b) {
    return a * b;
}

int main() {
    int result = add(10, 20);
    cout << "Addition result: " << result << endl;
    
    printMessage();
    
    int product = multiply(5, 6);
    cout << "Multiplication result: " << product << endl;
    
    return 0;  // return from main function
}

4. Class and Access Control Keywords

#include <iostream>
using namespace std;

class Student {
private:    // private keyword - private member
    string name;
    int age;

public:     // public keyword - public member
    // Constructor
    Student(string n, int a) : name(n), age(a) {}
    
    // Member function
    void display() {
        cout << "Name: " << name << ", Age: " << age << endl;
    }
    
    // protected keyword - protected member
protected:
    string studentId;
};

class GraduateStudent : public Student {  // public inheritance
public:
    GraduateStudent(string n, int a) : Student(n, a) {}
    
    void setStudentId(string id) {
        studentId = id;  // Can access base class protected member
    }
};

int main() {
    Student stu("Zhang San", 20);
    stu.display();
    
    return 0;
}

Correct and Incorrect Usage of Keywords

Correct Usage Examples

#include <iostream>
using namespace std;

// Correct: keyword as type specifier
int calculate(int a, int b) {
    return a * b;
}

// Correct: include keyword in identifier
class my_class {        // class is a keyword, but my_class is valid
private:
    int return_value;   // return is a keyword, but return_value is valid
    double double_data; // double is a keyword, but double_data is valid
    
public:
    void set_value(int value) {
        return_value = value;
    }
    
    int get_value() {
        return return_value;  // return keyword used correctly
    }
};

int main() {
    // Correct: using keywords to declare variables
    int number = 42;
    double precision_value = 3.14;
    bool flag = true;
    
    // Correct: variable names containing keywords
    int integer_number = 100;      // contains int keyword
    double double_precision = 2.71; // contains double keyword
    string return_address = "home"; // contains return keyword
    
    my_class obj;
    obj.set_value(50);
    cout << "Value: " << obj.get_value() << endl;
    
    return 0;
}

Incorrect Usage Examples

#include <iostream>
using namespace std;

// Incorrect example: the following code will cause compilation errors

/*
// Incorrect: using keyword as function name
int int(int a, int b) {    // Error! int is a keyword
    return a + b;
}

// Incorrect: using keyword as variable name
int double = 3.14;         // Error! double is a keyword
bool return = true;        // Error! return is a keyword
char class = 'A';          // Error! class is a keyword

// Incorrect: using keyword as class name
class public {             // Error! public is a keyword
private:
    int value;
};

// Incorrect: name conflict in the same scope
void myFunction() {
    int cout = 10;         // Error! If std::cout is used later, it will conflict
    cout << "Hello";       // Here cout is treated as int variable, not output stream
}
*/

// Correct alternatives
int calculate_int(int a, int b) {  // include keyword in name
    return a + b;
}

class PublicClass {                // use meaningful names, avoid keywords
private:
    int value;
};

int main() {
    double double_value = 3.14;    // variable name containing keyword
    bool return_flag = true;       // variable name containing keyword
    
    // Note: theoretically can use cout object in this case...
    // but not recommended as it can cause confusion
    /*
    {
        int cout = 42;  // in local scope, but highly discouraged!
        std::cout << "Value: " << cout << std::endl; // need to use std::
    }
    */
    
    return 0;
}

Complete Example: Comprehensive Use of Keywords

#include <iostream>
using namespace std;

// Class definition using multiple keywords
class Calculator {
private:
    double last_result;  // private member
    
public:
    // Constructor
    Calculator() : last_result(0) {}
    
    // const member function - does not modify object state
    double get_last_result() const {
        return last_result;
    }
    
    // static member function - does not depend on specific object
    static void show_help() {
        cout << "This is a calculator class" << endl;
    }
    
    // Template function - using template keyword
    template<typename T>
    T add(T a, T b) {
        last_result = a + b;
        return static_cast<T>(last_result);
    }
};

// Namespace usage
namespace MathOperations {
    const double PI = 3.141592653589793;
    
    double circle_area(double radius) {
        return PI * radius * radius;
    }
}

int main() {
    // Using various keywords
    Calculator calc;
    Calculator::show_help();  // Call static function
    
    auto result = calc.add(5.5, 3.2);  // auto keyword infers type
    cout << "Calculation result: " << result << endl;
    
    // Using namespace
    double area = MathOperations::circle_area(2.5);
    cout << "Circle area: " << area << endl;
    
    // Dynamic memory allocation - new and delete keywords
    int* numbers = new int[5];  // new keyword allocates memory
    for (int i = 0; i < 5; i++) {
        numbers[i] = i * 10;
    }
    
    for (int i = 0; i < 5; i++) {
        cout << numbers[i] << " ";
    }
    cout << endl;
    
    delete[] numbers;  // delete keyword frees memory
    
    return 0;
}

Important Notes

1. main is not a keyword: <span>main</span> is a required function name, but not a C++ keyword.
2. Avoid name conflicts: Do not use standard library names (like <span>cout</span>) as variable names.
3. Scope considerations: The same name can be used in different scopes, but confusion should be avoided.
4. Coding standards: Use meaningful names, avoid using keywords in identifiers unless necessary.

Compilation Test

# Compile correct example
g++ -o keywords_demo keywords_demo.cpp

# Run the program
./keywords_demo

Understanding the rules of keyword usage is crucial for writing correct C++ programs. Remember that keywords are the foundation of the language and must be used correctly according to language specifications.