//程序库开发人员
class Library{
public:
	void Step1(){
		//...
	}

    void Step3(){
		//...
    }

    void Step5(){
		//...
    }
};

//应用程序开发人员
class Application{
public:
	bool Step2(){
		//...
    }

    void Step4(){
		//...
    }
};

int main(){
	Library lib();
	Application app();
	
	lib.Step1();
	if (app.Step2()){
		lib.Step3();
	}
	for (int i = 0; i < 4; i++){
		app.Step4();
	}
	lib.Step5();
}

class Solution {
public:
	int knapsack(vector<int>& weight, vector<int>& value, int maxW) {
		// 物品数目
		int kinds = weight.size();
		// dp数组初始化为二维数组
		vector<vector<int>> dp(kinds + 1, vector<int>(maxW + 1, 0));
		// 状态一：可选的目标：0个可选，前一个可选、前两个可选、前三个可选，以此类推（与找零钱不同，物品不能重复选）
		for (int c = 1; c <= kinds; c++) {
			// 状态二：当前的可承载重量，0、1、2...maxW
			for (int w = 1; w <= maxW; w++) {
				// 该物品太大以至于当前重量超标：下标越界，直接赋值为“没有该物品时的最优答案”
				if (w - weight[c - 1] < 0) 
					dp[c][w] = dp[c - 1][w];
				// 比较，“不选择该物品”和“选择该物品”时，哪个价值大
				else
					dp[c][w] = max(dp[c - 1][w], dp[c - 1][w - weight[c - 1]] + value[c - 1]);
			}
		}
		return dp[kinds][maxW];
	}
};

/*
C++现在都是基于模板的迭代器，模板又称为编译时多态，速度肯定比虚函数的运行时多态要好很多
但是java、C#、PHP、Swift还是这种基于虚函数的迭代器（因为不支持编译时的模板机制）
*/
template<typename T>
class Iterator{
public:
    virtual void first() = 0;
    virtual void next() = 0;
    virtual bool isDone() const = 0;
    virtual T& current() = 0;
};

template<typename T>
class MyCollection{
public:
    Iterator<T>* GetIterator(){
        // ...
    }
};

template<typename T>
class CollectionIterator : public Iterator<T>{
    MyCollection<T> mc;
public:
    CollectionIterator(const MyCollection<T>& c): mc(c){ }
    
    void first() override {
        // ...
    }
    void next() override {
        // ...
    }
    bool isDone() const override{
        // ...
    }
    T& current() override{
        // ...
    }
};

void MyAlgorithm(){
    MyCollection<int> mc;
    Iterator<int>* iter = mc.GetIterator();
    for (iter->first(); !iter->isDone(); iter->next()){ // 多态
        cout << iter->current() << endl; // 多态
    }
}

class EmployeeDAO{
public:
    vector<EmployeeDO> GetEmployees(){
        SqlConnection* connection = new SqlConnection(); // 耦合
        connection->ConnectionString("...");

        SqlCommand* command = new SqlCommand(); // 耦合
        command->CommandText("...");
        command->SetConnection(connection);

        SqlDataReader* reader = command->ExecuteReader();
        while (reader->Read()){
            // ...
        }
    }
};

// FileSplitter.cpp
class ISplitter{
public:
    virtual void split()=0;
    virtual ~ISplitter(){}
};

// 多个具体的文件分割器
class BinarySplitter : public ISplitter{
    virtual void split(){
        // ...
    }
};

class TxtSplitter: public ISplitter{
    virtual void split(){
        // ...
    }
};

class PictureSplitter: public ISplitter{
    virtual void split(){
        // ...
    }
};

class VideoSplitter: public ISplitter{
    virtual void split(){
        // ...
    }
};

// MainForm.cpp
class MainForm : public Form{
public:
	void Button1_Click(){
		// 抽象依赖* ptr = new 具体依赖(); 违背依赖倒置原则，这样肯定不行的！
		ISplitter * splitter = new BinarySplitter(); //依赖具体类
        splitter->split();
	}
};

enum TaxBase {
	CN_Tax,
	US_Tax,
	DE_Tax,
	FR_Tax //更改：新添加
};

class SalesOrder{
    TaxBase tax;
public:
    double CalculateTax(){
        //...
        
        if (tax == CN_Tax){
            //CN***********
        }
        else if (tax == US_Tax){
            //US***********
        }
        else if (tax == DE_Tax){
            //DE***********
        }
		else if (tax == FR_Tax){  //更改
			//...
		}
        //....
     }
};

// FileSplitter.cpp
class FileSplitter{
	string m_filePath;
	int m_fileNumber;
	ProgressBar* m_progressBar; // 不能应对变化，和具体某个平台的进度条绑死：例如UI进度条、无界面的Shell进度条等等

public:
	FileSplitter(const string& filePath, int fileNumber, ProgressBar* progressBar) :
		m_filePath(filePath), 
		m_fileNumber(fileNumber),
		m_progressBar(progressBar){
	}

	void split(){
		//1.读取大文件
		// ...

		//2.分批次向小文件中写入
		for (int i = 0; i < m_fileNumber; i++){
			//...
			float progressValue = m_fileNumber;
			progressValue = (i + 1) / progressValue;
			m_progressBar->setValue(progressValue);
		}
	}
};

// MainForm.cpp
class MainForm : public Form{
	TextBox* txtFilePath;
	TextBox* txtFileNumber;
	ProgressBar* progressBar;

public:
	void Button1_Click(){
		string filePath = txtFilePath->getText();
		int number = atoi(txtFileNumber->getText().c_str());
		FileSplitter splitter(filePath, number, progressBar);
		splitter.split();
	}
};

#include <iostream>
#include <vector>
#include <thread>
#include <mutex>
using namespace std;
int idx = 0;
mutex _mutex;
void func(int n) {
	while (idx < n) { // 改成true一样的
		lock_guard<mutex> tmp(_mutex);
		if (idx >= n) break; // 必须，否则多输出几个数才停
		cout << idx++ << " ";
	}
}
int main() {
	vector<thread> arr;
	for (int i = 0; i < 10; ++i)
		arr.push_back(thread(func, 1000));
	for (auto& e : arr)
		e.join();
	return 0;
}