CS106L

struct Course {
	string code;
	vector<string> instructors;
}

// 遍历
void func(vector<Course>& courses) {
	for(auto& course : courses) {
		...
	}
}

// 初始化
Course test {"CS106L", {"A", "B"} };

template <typename InputIterator, typename UnaryPredicate>
int countOccurences(InputIterator begin, InputIterator end, UnaryPredicate predicate)
{
    int count = 0;
    for (auto iter = begin; iter != end; ++iter)
    {
        if (predicate(*iter))
            ++count;
    }
    return count;
}

template <typename DataType>
inline bool isLessThan5(DataType val)
{
    return val < 5;
}

vector<int> vec{1, 3, 5, 7, 9};
cout << countOccurences(vec.begin(), vec.end(), isLessThan5); // returns 2

// count and count_if
template<class InputIt, class T>
constexpr typename iterator_traits<InputIt>::difference_type 
count(InputIt first, InputIt last, const T &value);

// 返回值，常量表达式：返回迭代器类型的“差值类型”
// std::iterator_traits<> 模版结构体，提取迭代器类型信息

template<class InputIt, class UnaryPredicate>
constexpr typename iterator_traits<InputIt>::difference_type 
count_if(InputIt first, InputIt last, UnaryPredicate p);

// 给定区间是否有任意一个元素满足
bool has_even = std::any_of(v.begin(), v.end(), [](int x) {
	return x % 2 == 0;
});

// 查找第一个满足条件的元素, 返回迭代器
auto it = std::find_if(v.begin(), v.end(), [](int x) {
	return x % 2 == 0;
});

// 满足条件元素复制到另一个容器
std::vector<int> even; // 目标容器
std::copy_if(v.begin(), v.end(), std::back_inserter(even); [](int x) {
// 迭代器适配器，返回输出迭代器，调用 push_back
// 使得拷贝时候不会将元素放入未初始化的内存中，而是会不断增加内存
	return x % 2 == 0;
});

// v += "!";
vector<string>& vector<string>::operator+=(const string& element) {
	push_back(element);
	return *this;
}

// v += vec;
vector<string>& vector<string>::operator+=(const vector<int>& other) {
	for ( int val : other) push_back(val);
	return *this;
}

// 成员函数
StringVector StringVector::operator+(const StringVector& other) const {
	StringVector result = *this; // 创建新拷贝
	for(const std::string& s : other) {
		result += s;
	}
	return result;
}

// 非成员函数
StringVector operator+(const StringVector& first, const StringVector& second) {
	StringVector result = first;
	for (const std::string& s : second) result += s;
	return result;
}

private:
	std::string *elems;

Func::iterator Func::begin() {
	return elems;
}

// 拷贝构造函数
Func::Func(const Func& other) noexcept :
	var1(other.var1), var2(other.var2)
{
	elems = new std::string[20]; // 成员变量
	std::copy(other.begin(), other.end(), begin()); // 数组本身可当作迭代器使用
}

// 拷贝赋值函数
Func& Func::operator=(const Func& other) {
	// 检查指针是否相等
	if(this ！= &other) { // 解决自我赋值：a = a;
		
		delete[] elems;
		
		var1 = other.var1;
		var2 = other.var2;
		
		elems = new std::string[20];
		std::copy(other.begin(), other.end(), begin());
	}
	return *this;
}

#define LOG_FUNC(msg) \
    printf("%s\n", msg);

class StrVec {
public:
    char* data;
    size_t size;

    // ✅ 默认构造函数
    StrVec() : data(nullptr), size(0) {
        LOG_FUNC("Default Constructor");
    }

    // ✅ 构造函数（分配 size 个 'a'）
    StrVec(size_t sz, const char* c) : size(sz) {
        LOG_FUNC("Parameterized Constructor");
        data = new char[size + 1];
        memset(data, c[0], size);
        data[size] = '\0';
    }

    // ✅ 拷贝构造函数
    StrVec(const StrVec& other) : size(other.size) {
        LOG_FUNC("Copy Constructor");
        data = new char[size + 1];
        strcpy(data, other.data);
    }

    // ✅ 拷贝赋值运算符
    StrVec& operator=(const StrVec& other) {
        LOG_FUNC("Copy Assignment");
        if (this != &other) {
            delete[] data;
            size = other.size;
            data = new char[size + 1];
            strcpy(data, other.data);
        }
        return *this;
    }

    // ✅ 析构函数
    ~StrVec() {
        LOG_FUNC("Destructor");
        delete[] data;
    }
};

// main.cpp
// g++ -std=c++11 -fno-elide-constructors
StrVec readName(size_t size) {
	StrVec name(size, "a"); // 1. 构造函数  7. 构造函数
	return name; // 2. 拷贝构造函数 + 3 析构函数  8. 拷贝构造函数 + 9 析构函数
}

int main() {
	StrVec name1 = readName(123); // 4. 拷贝构造函数 + 5. 析构函数
	StrVec name2; // 6. 默认构造函数
	name2 = readName(123); // 10. 拷贝赋值函数 + 11. 析构函数
} // 12.13. 析构函数

// g++ -std=c++17
StrVec readName(size_t size) {
	StrVec name(size, "a"); // 1. 构造函数  3. 构造函数
	return name; 
}

int main() {
	StrVec name1 = readName(123);
	StrVec name2; // 2. 默认构造函数
	name2 = readName(123); // 4. 拷贝赋值函数 + 5. 析构函数
} // 6.7. 析构函数

int val = 2; // val: 左值
int *ptr = 0x123; // ptr: 左值
vector<int> v1{1, 2, 3}; // v1: 左值

auto& ptr2 = ptr; // ptr2 是左值引用，可以绑定左值 ptr，类似于 ptr2 为 ptr 别名
auto&& v4 = v1 + v2; // v4 是右值引用，可以绑定右值 v1 + v2，延长了生命周期
auto& ptr3 = &val; // NO：ptr3 是左值引用，不能绑定到右值 &val

auto&& val2 = val; // NO：val2 是右值引用，不能绑定到左值 val

const auto& ptr3 = ptr + 5; // ptr3 是常量左值引用，可以绑定到右值 ptr + 5

// 接口
class Drink {
public:
	// 纯虚函数
	virtual void make() = 0; // 强制任何集成了 Drink 类的类必须实现 make 函数，否则不能被视为真正的类
};

class Tea : public Drink {
public
	void make() {
		// 实现
	}
};

// 只要 istream 实现 print（非虚函数），且所有类型的流继承自 istream，则只需要写一个函数
void print(istream &stream, int i) {
	stream << i;
}

class B {
public:
    ~B() { // 更改为 virtual ~B 才会先调用 D destructor 再调用 B destructor
        std::cout << "B destructor\n";
    }
};

class D : public B {
public:
    ~D() {
        std::cout << "D destructor\n";
    }
};

int main() {
    B* b = new D();  // 指针类型是 B*，对象实际是 D
    delete b;        // ❓ 会调用 B destructor:  由于基类析构函数不是 virtual
								     // 所以只会调用编译器知道的类型的析构函数
}

class Q {
public:
	Q() = default;
	~Q() = default;
	
	int top() const {}
	void pop() {}
	void push(int val) {}
	friend std::ostream& operator<<(std::ostream& os, const Q q) {}
private:
	vector<int> _heap;
	size_t _count{0};
};

int main() {
	Q q;
	q.push(3);
	q.push(5);
	q.push(7);
	cout << q << endl;
}

template <class T, class Container = std::vector<T>>
class Q {
public:
	Q() = default;
	~Q() = default;
	
	T top() const {}
	void pop() {}
	void push(T val) {}
	friend std::ostream& operator<<(std::ostream& os, const Q q) {}
private:
	vector<T> _heap; // 也可以使用 Container _heap
	size_t _count{0};
};

int main() {
	Q<vector<string>, vector<vector<string>>> q;
	q.push({"about"});
	q.push({"bed"});
	q.push({"cute"});
	cout << q << endl;
}

string EvaluateSalaryAndReturnName (int idNumber) {
    Employee* e = new Employee(idNumber); // 分配堆上数据
    if (e->Title() == "CEO" || e->Salary() > 100000) {
			cout << e->First() << " "
				<< e->Last() << " is overpaid" << endl;
    }
		auto result = e->First() + " " + e->Last();
	    
		delete e;		// 释放堆上内存，若异常导致跳过这行，导致内存泄漏
    return result;
}

void greet(int id) {
	// nstd::this_thread::sleep_for(std::chrono::seconds(5));
	// 主线程超出作用域后，子线程将无法执行
	cout << "hello " << id << endl; // hello 1 和 hello 2 可能重叠
}

int main() {
	cout << "begin..." << endl;
	
	std::thread thread1(greet, 1);
	std::thread thread2(greet, 2);
	
	cout << "end;" << endl;
	
	return 0;
}

std::mutex mtx;

void greet(int id) {
	std::lock_guard<std::mutex> lg(mtx);
	cout << "hello " << id << endl;
}

int main() {
	cout << "begin..." << endl;
	
	std::thread thread1(greet, 1);
	std::thread thread2(greet, 2);
	
	cout << "end;" << endl;
	
	return 0;
}

std::mutex mtx;

void greet(int id) {
	std::lock_guard<std::mutex> lg(mtx);
	cout << "hello " << id << endl;
}

int main() {
	cout << "begin..." << endl;
	
	std::thread thread1(greet, 1);
	std::thread thread2(greet, 2);
	
	thread1.join();
	thread2.join(); // 等待 hello 均输出完，再往下执行
	
	cout << "end;" << endl;
	
	return 0;
}

std::mutex mtx;
const size_t num_thread = 10;
void greet(int id) {
	std::lock_guard<std::mutex> lg(mtx);
	cout << "hello " << id << endl;
}

int main() {
	cout << "begin..." << endl;
	
	vector<std::thread> threads;
	
	for(size_t i = 0; i < num_thread; i++){
		threads.push_back(std::thread(greet, i));
		// threads[i].join();
	} 
	
	for(std::thread& t : threads) { // 使用引用
		t.join();
	}
	
	cout << "end;" << endl;
	
	return 0;
}