002 《C++ 基础 (Fundamentals) - 全面且深度解析》

                                
                                    

                            
1
                            
#include <iostream>
                        

                            
2
                            

                        

                            
3
                            
int main() {
                        

                            
4
                            
    std::cout << "Hello, World!" << std::endl;
                        

                            
5
                            
    return 0;
                        

                            
6
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
g++ hello.cpp -o hello
                        
                                
                            

                                
                                    

                            
1
                            
clang++ hello.cpp -o hello
                        
                                
                            

                                
                                    

                            
1
                            
cl hello.cpp
                        
                                
                            

                                
                                    

                            
1
                            
./hello
                        
                                
                            

                                
                                    

                            
1
                            
hello.exe
                        
                                
                            

                                
                                    

                            
1
                            
Hello, World!
                        
                                
                            

                                
                                    

                            
1
                            
int age = 30;
                        

                            
2
                            
int temperature = -5;
                        

                            
3
                            
int count = 1000;
                        
                                
                            

                                
                                    

                            
1
                            
short smallNumber = 100;
                        

                            
2
                            
short negativeSmallNumber = -50;
                        
                                
                            

                                
                                    

                            
1
                            
long bigNumber = 1000000L; // 'L' 后缀表示 long 类型字面量
                        

                            
2
                            
long negativeBigNumber = -2000000L;
                        
                                
                            

                                
                                    

                            
1
                            
long long veryBigNumber = 10000000000LL; // 'LL' 后缀表示 long long 类型字面量
                        

                            
2
                            
long long negativeVeryBigNumber = -90000000000LL;
                        
                                
                            

                                
                                    

                            
1
                            
unsigned int positiveAge = 30U; // 'U' 后缀表示 unsigned int 类型字面量
                        

                            
2
                            
unsigned short smallPositiveNumber = 100U;
                        

                            
3
                            
unsigned long long veryBigPositiveNumber = 18446744073709551615ULL; // 'ULL' 后缀表示 unsigned long long 类型字面量
                        
                                
                            

                                
                                    

                            
1
                            
#include <cstdint>
                        

                            
2
                            
int32_t fixedInt = 1000; // 保证 32 位有符号整型
                        

                            
3
                            
uint64_t fixedUnsignedLongLong = 1000000000000ULL; // 保证 64 位无符号整型
                        
                                
                            

                                
                                    

                            
1
                            
#include <iostream>
                        

                            
2
                            

                        

                            
3
                            
int main() {
                        

                            
4
                            
    int decimalInt = 123;
                        

                            
5
                            
    int octalInt = 0123;    // 八进制 123，等于十进制 83
                        

                            
6
                            
    int hexInt = 0x123;     // 十六进制 123，等于十进制 291
                        

                            
7
                            
    unsigned int unsignedIntLiteral = 456U;
                        

                            
8
                            
    long long longLongLiteral = 789LL;
                        

                            
9
                            

                        

                            
10
                            
    std::cout << "Decimal: " << decimalInt << std::endl;
                        

                            
11
                            
    std::cout << "Octal: " << octalInt << std::endl;
                        

                            
12
                            
    std::cout << "Hexadecimal: " << hexInt << std::endl;
                        

                            
13
                            
    std::cout << "Unsigned Literal: " << unsignedIntLiteral << std::endl;
                        

                            
14
                            
    std::cout << "Long Long Literal: " << longLongLiteral << std::endl;
                        

                            
15
                            

                        

                            
16
                            
    return 0;
                        

                            
17
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
float price = 99.99f; // 'f' 后缀表示 float 类型字面量
                        

                            
2
                            
float temperatureFloat = 36.6f;
                        

                            
3
                            
float smallFloat = 0.000123f;
                        
                                
                            

                                
                                    

                            
1
                            
double pi = 3.141592653589793;
                        

                            
2
                            
double largeDouble = 1.23456789e100;
                        

                            
3
                            
double negativeDouble = -0.987654321;
                        
                                
                            

                                
                                    

                            
1
                            
long double veryPreciseValue = 3.141592653589793238462643383279502884L; // 'L' 后缀表示 long double 类型字面量
                        

                            
2
                            
long double largeLongDouble = 1.7E+4932L;
                        
                                
                            

                                
                                    

                            
1
                            
#include <iostream>
                        

                            
2
                            
#include <iomanip> // 用于设置输出精度
                        

                            
3
                            

                        

                            
4
                            
int main() {
                        

                            
5
                            
    float floatVar = 123.456f;
                        

                            
6
                            
    double doubleVar = 123.456;
                        

                            
7
                            
    long double longDoubleVar = 123.456L;
                        

                            
8
                            

                        

                            
9
                            
    std::cout << std::fixed << std::setprecision(7); // 设置输出浮点数精度为 7 位小数
                        

                            
10
                            

                        

                            
11
                            
    std::cout << "Float: " << floatVar << std::endl;
                        

                            
12
                            
    std::cout << std::setprecision(15); // 设置输出浮点数精度为 15 位小数
                        

                            
13
                            
    std::cout << "Double: " << doubleVar << std::endl;
                        

                            
14
                            
    std::cout << std::setprecision(20); // 设置输出浮点数精度为 20 位小数
                        

                            
15
                            
    std::cout << "Long Double: " << longDoubleVar << std::endl;
                        

                            
16
                            

                        

                            
17
                            
    return 0;
                        

                            
18
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#include <cmath> // 包含 fabs 函数
                        

                            
2
                            

                        

                            
3
                            
double a = 0.1 + 0.1 + 0.1;
                        

                            
4
                            
double b = 0.3;
                        

                            
5
                            
double epsilon = 1e-9; // 定义一个很小的 epsilon 值
                        

                            
6
                            

                        

                            
7
                            
if (std::fabs(a - b) < epsilon) {
                        

                            
8
                            
    std::cout << "a 和 b 在误差范围内相等" << std::endl;
                        

                            
9
                            
} else {
                        

                            
10
                            
    std::cout << "a 和 b 不相等" << std::endl;
                        

                            
11
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
char initial = 'J';
                        

                            
2
                            
char digitChar = '9';
                        

                            
3
                            
char symbolChar = '$';
                        

                            
4
                            
char newlineChar = '\n'; // 转义字符表示换行符
                        
                                
                            

                                
                                    

                            
1
                            
char tabChar = '\t';
                        

                            
2
                            
char backslashChar = '\\';
                        

                            
3
                            
char nullChar = '\0';
                        

                            
4
                            
char octalChar = '\101'; // 八进制 101，等于十进制 65，即 ASCII 字符 'A'
                        

                            
5
                            
char hexChar = '\x41';  // 十六进制 41，等于十进制 65，即 ASCII 字符 'A'
                        
                                
                            

                                
                                    

                            
1
                            
wchar_t chineseChar = L'中'; // 'L' 前缀表示宽字符字面量
                        

                            
2
                            
wchar_t japaneseChar = L'日';
                        

                            
3
                            
wchar_t emojiChar = L'😊';
                        
                                
                            

                                
                                    

                            
1
                            
char16_t utf16Char = u'你';
                        

                            
2
                            
char32_t utf32Emoji = U'😊';
                        

                            
3
                            
std::u16string utf16String = u"你好，世界！"; // C++11 的 std::u16string 类型
                        

                            
4
                            
std::u32string utf32String = U"你好，世界！"; // C++11 的 std::u32string 类型
                        
                                
                            

                                
                                    

                            
1
                            
#include <iostream>
                        

                            
2
                            
#include <string> // std::string
                        

                            
3
                            
#include <cwchar> // std::wcerr, std::wcout, std::wcin
                        

                            
4
                            
#include <locale> // std::locale, std::wcout.imbue
                        

                            
5
                            

                        

                            
6
                            
int main() {
                        

                            
7
                            
    char asciiChar = 'A';
                        

                            
8
                            
    wchar_t wideChar = L'Я'; // Cyrillic letter Ya
                        

                            
9
                            

                        

                            
10
                            
    std::cout << "ASCII char: " << asciiChar << std::endl;
                        

                            
11
                            

                        

                            
12
                            
    // 设置宽字符输出的本地化环境，以便正确显示宽字符
                        

                            
13
                            
    std::locale loc("");
                        

                            
14
                            
    std::wcout.imbue(loc);
                        

                            
15
                            
    std::wcout << L"Wide char: " << wideChar << std::endl;
                        

                            
16
                            

                        

                            
17
                            
    // 示例 UTF-8 字符串 (需要编译器和环境支持 UTF-8)
                        

                            
18
                            
    std::string utf8String = "你好，UTF-8！😊";
                        

                            
19
                            
    std::cout << "UTF-8 string: " << utf8String << std::endl;
                        

                            
20
                            

                        

                            
21
                            
    return 0;
                        

                            
22
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
bool isAdult = true;
                        

                            
2
                            
bool isRaining = false;
                        

                            
3
                            
bool result = (10 > 5); // 关系运算的结果是 bool 类型
                        

                            
4
                            

                        

                            
5
                            
std::cout << "isAdult: " << isAdult << std::endl; // 输出 1 (通常 true 输出为 1)
                        

                            
6
                            
std::cout << "isRaining: " << isRaining << std::endl; // 输出 0 (false 输出为 0)
                        

                            
7
                            
std::cout << "result: " << result << std::endl; // 输出 1
                        

                            
8
                            

                        

                            
9
                            
int intValue = 100;
                        

                            
10
                            
bool boolFromInt = intValue; // 非零整数转换为 true
                        

                            
11
                            
std::cout << "boolFromInt (from 100): " << boolFromInt << std::endl; // 输出 1
                        

                            
12
                            

                        

                            
13
                            
int zeroValue = 0;
                        

                            
14
                            
bool boolFromZero = zeroValue; // 零整数转换为 false
                        

                            
15
                            
std::cout << "boolFromZero (from 0): " << boolFromZero << std::endl; // 输出 0
                        
                                
                            

                                
                                    

                            
1
                            
std::cout << "Size of bool: " << sizeof(bool) << " bytes" << std::endl; // 通常输出 1
                        
                                
                            

                                
                                    

                            
1
                            
int age = 15;
                        

                            
2
                            
bool isTeenager = (age >= 13 && age <= 19);
                        

                            
3
                            

                        

                            
4
                            
if (isTeenager) {
                        

                            
5
                            
    std::cout << "青少年" << std::endl;
                        

                            
6
                            
} else {
                        

                            
7
                            
    std::cout << "非青少年" << std::endl;
                        

                            
8
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
bool hasLicense = true;
                        

                            
2
                            
bool hasCar = false;
                        

                            
3
                            

                        

                            
4
                            
bool canDrive = hasLicense && hasCar; // 逻辑与：必须同时拥有驾照和车才能开车
                        

                            
5
                            
bool canTravel = hasLicense || hasCar; // 逻辑或：拥有驾照或车就可以出行 (假设出行方式不限)
                        

                            
6
                            
bool cannotDrive = !canDrive;         // 逻辑非：不能开车
                        

                            
7
                            

                        

                            
8
                            
std::cout << "Can drive: " << canDrive << std::endl;   // 输出 0 (false)
                        

                            
9
                            
std::cout << "Can travel: " << canTravel << std::endl; // 输出 1 (true)
                        

                            
10
                            
std::cout << "Cannot drive: " << cannotDrive << std::endl; // 输出 1 (true)
                        
                                
                            

                                
                                    

                            
1
                            
bool isDataLoaded = false;
                        

                            
2
                            

                        

                            
3
                            
// ... 加载数据的代码 ...
                        

                            
4
                            
isDataLoaded = true; // 数据加载完成后，设置标志位为 true
                        

                            
5
                            

                        

                            
6
                            
if (isDataLoaded) {
                        

                            
7
                            
    // ... 基于已加载数据进行后续操作 ...
                        

                            
8
                            
    std::cout << "数据已加载，可以进行后续操作。" << std::endl;
                        

                            
9
                            
} else {
                        

                            
10
                            
    std::cout << "数据尚未加载，请先加载数据。" << std::endl;
                        

                            
11
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
bool isEven(int number) {
                        

                            
2
                            
    return (number % 2 == 0); // 如果是偶数，返回 true，否则返回 false
                        

                            
3
                            
}
                        

                            
4
                            

                        

                            
5
                            
int num1 = 10;
                        

                            
6
                            
int num2 = 7;
                        

                            
7
                            

                        

                            
8
                            
std::cout << num1 << " is even: " << isEven(num1) << std::endl; // 输出 10 is even: 1 (true)
                        

                            
9
                            
std::cout << num2 << " is even: " << isEven(num2) << std::endl; // 输出 7 is even: 0 (false)
                        
                                
                            

                                
                                    

                            
1
                            
bool boolValue = true;
                        

                            
2
                            
int intFromBool = boolValue; // bool 转换为 int
                        

                            
3
                            
std::cout << "intFromBool (from true): " << intFromBool << std::endl; // 输出 1
                        

                            
4
                            

                        

                            
5
                            
int intValueForBool = 5;
                        

                            
6
                            
bool boolFromIntImplicit = intValueForBool; // int 隐式转换为 bool
                        

                            
7
                            
std::cout << "boolFromIntImplicit (from 5): " << boolFromIntImplicit << std::endl; // 输出 1
                        
                                
                            

                                
                                    

                            
1
                            
int age;          // 声明一个整型变量 age
                        

                            
2
                            
double salary;     // 声明一个双精度浮点型变量 salary
                        

                            
3
                            
char initial;       // 声明一个字符型变量 initial
                        

                            
4
                            
bool isLoggedIn;   // 声明一个布尔型变量 isLoggedIn
                        

                            
5
                            

                        

                            
6
                            
int x, y, z;      // 声明三个整型变量 x, y, z
                        
                                
                            

                                
                                    

                            
1
                            
int count = 0;
                        

                            
2
                            
double pi = 3.14159;
                        

                            
3
                            
char grade = 'A';
                        

                            
4
                            
bool isReady = true;
                        
                                
                            

                                
                                    

                            
1
                            
int value = 100;
                        
                                
                            

                                
                                    

                            
1
                            
int number{42};
                        

                            
2
                            
double price{99.99};
                        

                            
3
                            
char symbol{'#'};
                        

                            
4
                            
bool isValid{false};
                        

                            
5
                            
int a, b, c{10}; // 只有 c 被初始化为 10，a 和 b 未初始化
                        

                            
6
                            

                        

                            
7
                            
int x{}; // 值初始化为 0 (对于数值类型) 或 null (对于指针类型)
                        

                            
8
                            
double y{}; // 值初始化为 0.0
                        

                            
9
                            
bool z{}; // 值初始化为 false
                        

                            
10
                            

                        

                            
11
                            
int narrowConversion{3.14}; // 警告或错误：窄化转换，列表初始化会阻止窄化转换
                        
                                
                            

                                
                                    

                            
1
                            
int defaultInt{};     // 值初始化为 0
                        

                            
2
                            
double defaultDouble{}; // 值初始化为 0.0
                        

                            
3
                            
bool defaultBool{};   // 值初始化为 false
                        

                            
4
                            
int* defaultPtr{};    // 值初始化为 nullptr (空指针)
                        
                                
                            

                                
                                    

                            
1
                            
#include <iostream>
                        

                            
2
                            

                        

                            
3
                            
int main() {
                        

                            
4
                            
    // 变量声明和初始化示例
                        

                            
5
                            

                        

                            
6
                            
    // 直接初始化
                        

                            
7
                            
    int age = 25;
                        

                            
8
                            
    double price = 129.99;
                        

                            
9
                            
    char grade = 'B';
                        

                            
10
                            
    bool isActive = true;
                        

                            
11
                            

                        

                            
12
                            
    // 拷贝初始化
                        

                            
13
                            
    int count = 100;
                        

                            
14
                            

                        

                            
15
                            
    // 列表初始化 (统一初始化)
                        

                            
16
                            
    int quantity{50};
                        

                            
17
                            
    double temperature{28.5};
                        

                            
18
                            
    char symbol{'$'};
                        

                            
19
                            
    bool isValid{true};
                        

                            
20
                            
    int defaultValue{}; // 值初始化为 0
                        

                            
21
                            

                        

                            
22
                            
    std::cout << "Age: " << age << std::endl;
                        

                            
23
                            
    std::cout << "Price: " << price << std::endl;
                        

                            
24
                            
    std::cout << "Grade: " << grade << std::endl;
                        

                            
25
                            
    std::cout << "Is Active: " << isActive << std::endl;
                        

                            
26
                            
    std::cout << "Count: " << count << std::endl;
                        

                            
27
                            
    std::cout << "Quantity: " << quantity << std::endl;
                        

                            
28
                            
    std::cout << "Temperature: " << temperature << std::endl;
                        

                            
29
                            
    std::cout << "Symbol: " << symbol << std::endl;
                        

                            
30
                            
    std::cout << "Is Valid: " << isValid << std::endl;
                        

                            
31
                            
    std::cout << "Default Value (int): " << defaultValue << std::endl;
                        

                            
32
                            

                        

                            
33
                            
    return 0;
                        

                            
34
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
const double PI = 3.1415926; // 编译时常量，通常建议使用大写字母命名常量
                        

                            
2
                            
const int MAX_SIZE = 100;
                        

                            
3
                            
const int runtimeValue = getRuntimeValue(); // 运行时常量，值在运行时确定
                        

                            
4
                            

                        

                            
5
                            
// PI = 3.14; // 错误：尝试修改 const 变量的值，编译错误
                        
                                
                            

                                
                                    

                            
1
                            
const int* ptr = &MAX_SIZE; // ptr 是指向 const int 的指针
                        

                            
2
                            
// *ptr = 200; // 错误：不能通过 ptr 修改所指对象的值
                        

                            
3
                            
int anotherValue = 300;
                        

                            
4
                            
ptr = &anotherValue; // 正确：ptr 指针本身可以指向其他地址
                        
                                
                            

                                
                                    

                            
1
                            
int value = 400;
                        

                            
2
                            
int* const constPtr = &value; // constPtr 是常量指针，指向 int
                        

                            
3
                            
*constPtr = 500; // 正确：可以通过 constPtr 修改所指对象的值
                        

                            
4
                            
// int anotherValue2 = 600;
                        

                            
5
                            
// constPtr = &anotherValue2; // 错误：不能修改 constPtr 指针本身的值 (地址)
                        
                                
                            

                                
                                    

                            
1
                            
const int constConstValue = 700;
                        

                            
2
                            
const int* const constConstPtr = &constConstValue; // constConstPtr 是指向 const int 的常量指针
                        

                            
3
                            
// *constConstPtr = 800; // 错误：不能通过 constConstPtr 修改所指对象的值
                        

                            
4
                            
// int anotherValue3 = 900;
                        

                            
5
                            
// constConstPtr = &anotherValue3; // 错误：不能修改 constConstPtr 指针本身的值 (地址)
                        
                                
                            

                                
                                    

                            
1
                            
const int& constRef = MAX_SIZE; // constRef 是 const 引用，引用 const int
                        

                            
2
                            
// constRef = 1000; // 错误：不能通过 constRef 修改所引用对象的值
                        
                                
                            

                                
                                    

                            
1
                            
class MyClass {
                        

                            
2
                            
public:
                        

                            
3
                            
    int getValue() const { // const 成员函数
                        

                            
4
                            
        return value_; // 只能访问 const 成员变量或调用 const 成员函数
                        

                            
5
                            
        // value_ = 10; // 错误：const 成员函数不能修改成员变量
                        

                            
6
                            
    }
                        

                            
7
                            
private:
                        

                            
8
                            
    int value_ = 0;
                        

                            
9
                            
};
                        
                                
                            

                                
                                    

                            
1
                            
constexpr double COMPILE_TIME_PI = 3.1415926535; // 编译时常量
                        

                            
2
                            
constexpr int ARRAY_SIZE = 10;
                        

                            
3
                            
int runtimeValue2 = 20;
                        

                            
4
                            
// constexpr int compileTimeError = runtimeValue2; // 错误：runtimeValue2 的值在运行时确定，不能用于 constexpr
                        

                            
5
                            

                        

                            
6
                            
int myArray[ARRAY_SIZE]; // 正确：数组大小可以使用 constexpr 常量
                        

                            
7
                            
// int myArray2[runtimeValue2]; // 错误：数组大小必须是编译时常量 (C++20 之前)
                        
                                
                            

                                
                                    

                            
1
                            
constexpr int square(int n) { // constexpr 函数，计算平方
                        

                            
2
                            
    return n * n;
                        

                            
3
                            
}
                        

                            
4
                            

                        

                            
5
                            
constexpr int compileTimeSquare = square(5); // 编译时求值
                        

                            
6
                            
int runtimeInput = 6;
                        

                            
7
                            
int runtimeSquare = square(runtimeInput);   // 运行时求值
                        

                            
8
                            

                        

                            
9
                            
static_assert(compileTimeSquare == 25, "编译时平方计算错误"); // 编译时断言，检查编译时常量的值
                        
                                
                            

                                
                                    

                            
1
                            
class Point {
                        

                            
2
                            
public:
                        

                            
3
                            
    constexpr Point(int x = 0, int y = 0) : x_(x), y_(y) {} // constexpr 构造函数
                        

                            
4
                            
    constexpr int getX() const { return x_; }
                        

                            
5
                            
    constexpr int getY() const { return y_; }
                        

                            
6
                            
private:
                        

                            
7
                            
    int x_;
                        

                            
8
                            
    int y_;
                        

                            
9
                            
};
                        

                            
10
                            

                        

                            
11
                            
constexpr Point compileTimePoint(1, 2); // 编译时构造 constexpr 对象
                        

                            
12
                            
static_assert(compileTimePoint.getX() == 1, "编译时 Point 对象构造错误");
                        
                                
                            

                                
                                    

                            
1
                            
#include <iostream>
                        

                            
2
                            

                        

                            
3
                            
constexpr int COMPILE_TIME_VALUE = 123; // 编译时常量
                        

                            
4
                            
const int RUN_TIME_VALUE = getRuntimeValue(); // 运行时常量 (假设 getRuntimeValue() 是一个运行时函数)
                        

                            
5
                            

                        

                            
6
                            
int main() {
                        

                            
7
                            
    std::cout << "Compile-time constant: " << COMPILE_TIME_VALUE << std::endl;
                        

                            
8
                            
    std::cout << "Run-time constant: " << RUN_TIME_VALUE << std::endl;
                        

                            
9
                            

                        

                            
10
                            
    return 0;
                        

                            
11
                            
}
                        

                            
12
                            

                        

                            
13
                            
int getRuntimeValue() {
                        

                            
14
                            
    return 456; // 假设此函数在运行时返回一个值
                        

                            
15
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
void myFunction() {
                        

                            
2
                            
    int localVar = 10; // localVar 具有块作用域，仅在 myFunction 函数体内可见
                        

                            
3
                            
    if (true) {
                        

                            
4
                            
        int innerVar = 20; // innerVar 具有更小的块作用域，仅在 if 语句块内可见
                        

                            
5
                            
        std::cout << localVar << std::endl; // 正确：在 inner block 中可以访问外层块的 localVar
                        

                            
6
                            
        std::cout << innerVar << std::endl;
                        

                            
7
                            
    }
                        

                            
8
                            
    std::cout << localVar << std::endl; // 正确：在 myFunction 函数体内可以访问 localVar
                        

                            
9
                            
    // std::cout << innerVar << std::endl; // 错误：在 if 语句块外部不能访问 innerVar
                        

                            
10
                            
}
                        

                            
11
                            
// std::cout << localVar << std::endl; // 错误：在 myFunction 函数外部不能访问 localVar
                        
                                
                            

                                
                                    

                            
1
                            
void processValue(int param) { // param 具有函数作用域，在 processValue 函数体内可见
                        

                            
2
                            
    std::cout << param << std::endl; // 正确：在函数体内可以访问函数参数 param
                        

                            
3
                            
}
                        

                            
4
                            
// std::cout << param << std::endl; // 错误：在 processValue 函数外部不能访问函数参数 param
                        
                                
                            

                                
                                    

                            
1
                            
namespace MyNamespace {
                        

                            
2
                            
    int namespaceVar = 30; // namespaceVar 具有命名空间作用域，在 MyNamespace 命名空间内可见
                        

                            
3
                            

                        

                            
4
                            
    void myFunctionInNamespace() {
                        

                            
5
                            
        std::cout << namespaceVar << std::endl; // 正确：在命名空间内可以访问 namespaceVar
                        

                            
6
                            
    }
                        

                            
7
                            
}
                        

                            
8
                            

                        

                            
9
                            
int main() {
                        

                            
10
                            
    std::cout << MyNamespace::namespaceVar << std::endl; // 正确：在命名空间外部通过命名空间名::变量名访问
                        

                            
11
                            
    MyNamespace::myFunctionInNamespace();
                        

                            
12
                            
    return 0;
                        

                            
13
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
int globalVar = 40; // globalVar 具有全局作用域，在整个程序中可见
                        

                            
2
                            

                        

                            
3
                            
void anotherFunction() {
                        

                            
4
                            
    std::cout << globalVar << std::endl; // 正确：在函数内可以访问全局变量 globalVar
                        

                            
5
                            
    std::cout << ::globalVar << std::endl; // 使用全局作用域解析运算符访问全局变量
                        

                            
6
                            
}
                        

                            
7
                            

                        

                            
8
                            
int main() {
                        

                            
9
                            
    std::cout << globalVar << std::endl; // 正确：在 main 函数内可以访问全局变量 globalVar
                        

                            
10
                            
    anotherFunction();
                        

                            
11
                            
    return 0;
                        

                            
12
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
class MyClass2 {
                        

                            
2
                            
public:
                        

                            
3
                            
    int memberVar = 50; // memberVar 具有类作用域，在 MyClass2 类内可见
                        

                            
4
                            

                        

                            
5
                            
    void memberFunction() {
                        

                            
6
                            
        std::cout << memberVar << std::endl; // 正确：在类成员函数内可以访问成员变量 memberVar
                        

                            
7
                            
    }
                        

                            
8
                            
};
                        

                            
9
                            

                        

                            
10
                            
int main() {
                        

                            
11
                            
    MyClass2 obj;
                        

                            
12
                            
    std::cout << obj.memberVar << std::endl; // 正确：通过对象访问成员变量
                        

                            
13
                            
    obj.memberFunction();
                        

                            
14
                            
    return 0;
                        

                            
15
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
int globalValue = 100;
                        

                            
2
                            

                        

                            
3
                            
void testScopeHiding() {
                        

                            
4
                            
    int globalValue = 200; // 内层块作用域的 globalValue 遮蔽了全局作用域的 globalValue
                        

                            
5
                            
    std::cout << "Inner globalValue: " << globalValue << std::endl; // 输出内层作用域的 globalValue (200)
                        

                            
6
                            
    std::cout << "Global globalValue: " << ::globalValue << std::endl; // 使用 :: 访问全局作用域的 globalValue (100)
                        

                            
7
                            
}
                        

                            
8
                            

                        

                            
9
                            
int main() {
                        

                            
10
                            
    testScopeHiding();
                        

                            
11
                            
    std::cout << "Global globalValue in main: " << globalValue << std::endl; // 在 main 函数中访问全局作用域的 globalValue (100)
                        

                            
12
                            
    return 0;
                        

                            
13
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
void autoStorageFunction() {
                        

                            
2
                            
    int autoVar = 60; // autoVar 具有自动存储期，在 autoStorageFunction 函数调用时创建，函数返回时销毁
                        

                            
3
                            
    std::cout << "Auto variable: " << autoVar << std::endl;
                        

                            
4
                            
} // autoVar 在这里销毁
                        

                            
5
                            

                        

                            
6
                            
int main() {
                        

                            
7
                            
    autoStorageFunction(); // 调用 autoStorageFunction 函数，autoVar 被创建和使用
                        

                            
8
                            
    // std::cout << autoVar << std::endl; // 错误：autoVar 在 autoStorageFunction 函数外部已销毁
                        

                            
9
                            
    return 0;
                        

                            
10
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
int staticGlobalVar = 70; // 具有静态存储期的全局变量，程序启动时创建，程序结束时销毁
                        

                            
2
                            

                        

                            
3
                            
namespace MyNamespace2 {
                        

                            
4
                            
    static int staticNamespaceVar = 80; // 具有静态存储期的命名空间变量，程序启动时创建，程序结束时销毁
                        

                            
5
                            
}
                        

                            
6
                            

                        

                            
7
                            
int main() {
                        

                            
8
                            
    std::cout << "Static global variable: " << staticGlobalVar << std::endl;
                        

                            
9
                            
    std::cout << "Static namespace variable: " << MyNamespace2::staticNamespaceVar << std::endl;
                        

                            
10
                            
    return 0;
                        

                            
11
                            
} // staticGlobalVar 和 staticNamespaceVar 在程序结束时销毁
                        
                                
                            

                                
                                    

                            
1
                            
void staticLocalVarFunction() {
                        

                            
2
                            
    static int count = 0; // 静态局部变量，第一次调用时初始化为 0，之后调用保持上次的值
                        

                            
3
                            
    count++;
                        

                            
4
                            
    std::cout << "Static local count: " << count << std::endl;
                        

                            
5
                            
}
                        

                            
6
                            

                        

                            
7
                            
int main() {
                        

                            
8
                            
    staticLocalVarFunction(); // 第一次调用，count 初始化为 0，然后递增为 1，输出 1
                        

                            
9
                            
    staticLocalVarFunction(); // 第二次调用，count 保持上次的值 1，然后递增为 2，输出 2
                        

                            
10
                            
    staticLocalVarFunction(); // 第三次调用，count 保持上次的值 2，然后递增为 3，输出 3
                        

                            
11
                            
    return 0;
                        

                            
12
                            
} // 静态局部变量 count 在程序结束时销毁
                        
                                
                            

                                
                                    

                            
1
                            
int* dynamicVarPtr = new int; // 在堆上动态分配一个 int 类型的内存，dynamicVarPtr 指向该内存
                        

                            
2
                            
*dynamicVarPtr = 90;
                        

                            
3
                            
std::cout << "Dynamic variable: " << *dynamicVarPtr << std::endl;
                        

                            
4
                            

                        

                            
5
                            
delete dynamicVarPtr; // 显式释放动态分配的内存，dynamicVarPtr 指针本身仍然存在，但指向的内存已无效
                        

                            
6
                            
dynamicVarPtr = nullptr; // 良好的习惯是将释放后的指针置为 nullptr，避免悬空指针
                        

                            
7
                            

                        

                            
8
                            
// 如果没有 delete dynamicVarPtr; 将会导致内存泄漏
                        
                                
                            

                                
                                    

                            
1
                            
#include <iostream>
                        

                            
2
                            

                        

                            
3
                            
int globalCounter = 0; // 全局变量
                        

                            
4
                            

                        

                            
5
                            
void exampleFunction() {
                        

                            
6
                            
    int localCounter = 0; // 局部变量，自动存储期
                        

                            
7
                            
    static int staticLocalCounter = 0; // 静态局部变量，静态存储期
                        

                            
8
                            

                        

                            
9
                            
    globalCounter++;
                        

                            
10
                            
    localCounter++;
                        

                            
11
                            
    staticLocalCounter++;
                        

                            
12
                            

                        

                            
13
                            
    std::cout << "Global Counter: " << globalCounter << std::endl;
                        

                            
14
                            
    std::cout << "Local Counter: " << localCounter << std::endl;
                        

                            
15
                            
    std::cout << "Static Local Counter: " << staticLocalCounter << std::endl;
                        

                            
16
                            
}
                        

                            
17
                            

                        

                            
18
                            
int main() {
                        

                            
19
                            
    exampleFunction();
                        

                            
20
                            
    exampleFunction();
                        

                            
21
                            
    exampleFunction();
                        

                            
22
                            
    return 0;
                        

                            
23
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
int sum = 10 + 5;      // 整数加法，结果为 15
                        

                            
2
                            
double sumDouble = 3.14 + 2.71; // 浮点数加法
                        

                            
3
                            
char charSum = 'A' + 3; // 字符加法，字符 'A' 的 ASCII 值加上 3，结果为字符 'D'
                        
                                
                            

                                
                                    

                            
1
                            
int difference = 20 - 8;   // 整数减法，结果为 12
                        

                            
2
                            
double diffDouble = 5.6 - 2.1; // 浮点数减法
                        

                            
3
                            
char charDiff = 'Z' - 5;   // 字符减法，字符 'Z' 的 ASCII 值减去 5，结果为字符 'U'
                        
                                
                            

                                
                                    

                            
1
                            
int product = 7 * 6;      // 整数乘法，结果为 42
                        

                            
2
                            
double prodDouble = 2.5 * 4.0; // 浮点数乘法
                        
                                
                            

                                
                                    

                            
1
                            
int intDivision1 = 10 / 3;  // 整数除法，结果为 3 (小数部分 .333 被舍弃)
                        

                            
2
                            
int intDivision2 = -10 / 3; // 整数除法，结果为 -3 (小数部分被舍弃)
                        
                                
                            

                                
                                    

                            
1
                            
double floatDivision1 = 10.0 / 3; // 浮点数除法，结果为 3.333...
                        

                            
2
                            
double floatDivision2 = 10 / 3.0; // 浮点数除法，结果为 3.333...
                        

                            
3
                            
double floatDivision3 = 10.0 / 3.0; // 浮点数除法，结果为 3.333...
                        
                                
                            

                                
                                    

                            
1
                            
int remainder1 = 10 % 3;  // 取模运算，10 除以 3 的余数为 1
                        

                            
2
                            
int remainder2 = -10 % 3; // 取模运算，-10 除以 3 的余数为 -1
                        

                            
3
                            
int remainder3 = 10 % -3; // 取模运算，10 除以 -3 的余数为 1
                        

                            
4
                            
int remainder4 = -10 % -3; // 取模运算，-10 除以 -3 的余数为 -1