Effective C++ 学习笔记

#define PI 3.14159

#include <iostream>
class MyClass {
public:
    static const int classConstant = 42; // 类专属常量
    static const double pi; // 声明，定义在类外部
    void printClassConstant() {
        std::cout << "Class constant: " << classConstant << std::endl;
    }
};
const double MyClass::pi = 3.1415926; // 在类外部定义类专属常量
int main() {
    MyClass obj;
    obj.printClassConstant(); // 调用类专属常量的成员函数
    std::cout << "Pi: " << MyClass::pi << std::endl; // 通过类名访问类专属常量
    return 0;
}

//错误的，ConstNumber 虽然是类的静态常量，但是它在编译期是无法确定的，因此不能用作数组大小。
class ANonDefine
{
public:
	static const int ConstNumber;
	 int Array[ConstNumber];
};

class ANonDefine
{
public:
	enum {ArraySize=5};
	int Array[ArraySize];
};

#include <iostream>
#define MAX_MACRO(a, b) ((a) >= (b) ? (a) : (b))
inline int max_inline(int a, int b) {
    return (a >= b) ? a : b;
}
int main() {
    int x = 5, y = 6;
    int result_macro = MAX_MACRO(++x, y); // 使用宏，产生不同的结果
    x = 5; y = 6; // 正确的变量赋值
    int result_inline = max_inline(++x, y); // 使用内联函数，产生不同的结果
    std::cout << "Macro result: " << result_macro << std::endl; //7
    std::cout << "Inline result: " << result_inline << std::endl;//6
    system("pause");
    return 0;
}

// const出现在*左边，表示被指物是常量，出现在*右边，表示指针自身是常量
const int x = 5;  // 声明一个不可修改的整数常量
const int* ptr = &x;  // 声明一个指向常量的指针，指针指向的常量不可修改
int const * ptr = &x;  // 声明一个指向常量的指针，指针指向的常量不可修改
int y = 10;
int* const ptr = &y;  // 声明一个指针常量，指针不可修改
const int* const ptr = &y;  // 指针及其指向的常量都不可修改

std::vector<int>Vector;
for(int i=0;i<10;++i)
{
    Vector.push_back(i);
}
const std::vector<int>::iterator Iterator=Vector.begin();
*Iterator=10;//所指物可以修改
//Iterator++;迭代器不可修改
std::vector<int>::const_iterator ConstIterator=Vector.begin();
//*ConstIterator=10;所指物不可修改
ConstIterator++;//指针可以修改
for (auto i=ConstIterator;i!=Vector.end();++i)
{
	FFunctionLibrary::Println(*i);
}

#include <iostream>
class MyClass {
public:
    void printValue() {
        std::cout << "Non-const function: " << value << std::endl;
    }
    void printValue() const {
        std::cout << "Const function: " << value << std::endl;
    }
    void setValue(int newValue) {
        value = newValue;
    }
private:
    int value = 0;
};
int main() {
    MyClass obj;
    const MyClass constObj;
    obj.setValue(42);
    obj.printValue();      // 调用非常量成员函数
    constObj.printValue(); // 调用常量成员函数
    return 0;
}

class MyClass {
public:
    int getValue() const; // 声明常量成员函数
private:
    mutable int count;   // 声明一个可变成员变量
};
int MyClass::getValue() const {
    // 在常量成员函数内修改可变成员变量
    count++;