1、C++实现某系统的任务管理模块，要求如下：

a1）系统中的任务分为如下三类：
    1.1 获取文件列表，需要保存要获取文件列表的目录
    1.2 上传文件，需要保存文件名、上传者昵称
    1.3 下载文件，需要下载的文件路径、下载次数
2）编写一个类实现对任务的管理，系统有友好的菜单，菜单如下：
    1、添加任务      2、显示所有任务     3、退出系统
 
PS: 所有信息都由用户输入，输入啥，保存啥就好，和文件没有关系
PS: 所有信息都由用户输入，输入啥，保存啥就好，和文件没有关系
PS: 所有信息都由用户输入，输入啥，保存啥就好，和文件没有关系 

任何一个任务都可以先添加，也可添加很多个。
输入示例：
步骤1：选择1、添加任务
步骤2：选择要添加的任务类型，
步骤3：假设选择“获取文件列表”
步骤4：输入要获取文件列表的目录： D:\test
步骤5：选择2、显示所有任务
   显示如下信息：
   任务类型: 文件列表       路径:D:\test
   任务类型: 上传文件       保存路径：C:\Test\1.txt    上传者:吖吖
   任务类型: 下载文件       下载路径：D:\Test\1.txt    下载次数:10次

主文件：

// test1106.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "App.h"

int main()
{
	App app;
	app.run();
    return 0;
}

 App.h

#pragma once
#include "Task.h"

class App
{
public:
	App();
	~App();

	void run();//提供一个接口，用来统计的入口
private:
	void add();//添加任务
	void display();//显示所有任务

	Task* get(int n) const;
private:
	Task *arr[1024];
	int  pos;
};

App.cpp

#include "stdafx.h"
#include "App.h"
#include <iostream>
#include "Task1.h"
#include "Task2.h"
#include "Task3.h"
using namespace std;

App::App()
	: pos(0)
{
}


App::~App()
{
}

void App::run()
{
	while (true)
	{
		cout << "1、添加任务      2、显示所有任务     3、退出系统\n:";
		int n;
		cin >> n;
		if (n == 1) add();//添加任务
		else if (n == 2) display();//显示所有任务
		else if (n == 3) break;
	}
}

void App::add()//添加任务
{
	cout << "请选择任务类型, 1、文件列表 2、上传文件 3、下载文件\n:";
	int n;
	cin >> n;
	Task *pTask = get(n);//调用get()函数   Task *pTask = new  ?;
	if (pTask) {
		pTask->read();//read是输入
		arr[pos++] = pTask;
	}
}

void App::display()//显示所有任务
{
	for (int i = 0; i < pos; ++i) {
		arr[i]->write();//write是输出
	}
}

Task * App::get(int n) const//根据用户输入n的值，判断执行几号任务
{
	if (n == 1) return new Task1;
	else if (n == 2) return new Task2;
	else if (n == 3) return new Task3;
	return nullptr;
}

 Task.h

#pragma once
class Task
{
	//在这个类当中无法实现读和写的功能，因此在派生类当中实现
public:
	Task();
	~Task();

	virtual void read();//对于任务的输入
	virtual void write() const;//任务的输出
	
	//任务中共同的特征是会显示路径（共同的特征放到基类当中）
protected:
	char path[64];
};

Task.cpp

#include "stdafx.h"
#include "Task.h"


Task::Task()
{
}


Task::~Task()
{
}

void Task::read()
{
}

void Task::write() const
{
}

Task1.h

#pragma once
#include "Task.h"
class Task1 :
	public Task//继承task，由于task作为基类中，已有路径定义，继承过来即可。
{
public:
	Task1();
	~Task1();

	virtual void read();//对于路径的输入
	virtual void write() const;//路径的输出
};

 Task1.cpp

#include "stdafx.h"
#include "Task1.h"
#include <iostream>
using namespace std;

Task1::Task1()
{
}


Task1::~Task1()
{
}

void Task1::read()//对于路径的输入
{
	cout << "文件列表，格式：路径\n";
	cin >> path;
}

void Task1::write() const//路径的输出
{
	cout << "任务类型: 文件列表       路径:" << path << endl;
}

Task2.h

#pragma once
#include "Task.h"
class Task2 :
	public Task//同样继承基类的path（路径）
{
public:
	Task2();
	~Task2();

	virtual void read();//对于路径、上传者的输入
	virtual void write() const;//路径和上传者的输出

protected://因此在基类的基础上，定义一个  上传者
	char name[32];
};

Task2.cpp

#include "stdafx.h"
#include "Task2.h"
#include <iostream>
using namespace std;	

Task2::Task2()
{
}


Task2::~Task2()
{
}

void Task2::read()
{
	cout << "上传文件，格式：保存路径 上传者\n";
	cin >> path >> name;
}

void Task2::write() const
{
	cout << "任务类型: 上传文件       保存路径："
		<< path << "    上传者:" << name << endl;
}

Task3.h

#pragma once
#include "Task.h"
class Task3 :
	public Task//同样继承基类的path（路径）
{
public:
	Task3();
	~Task3();

	virtual void read();//对于路径、下载次数的输入
	virtual void write() const;//路径和下载次数的输出

private:
	int cnt;

};

Task3.cpp

#include "stdafx.h"
#include "Task3.h"
#include <iostream>
using namespace std;

Task3::Task3()
{
}


Task3::~Task3()
{
}

void Task3::read()
{
	cout << "上传文件，格式：下载路径 下载次数\n";
	cin >> path >> cnt;
}

void Task3::write() const
{
	cout << "任务类型: 下载文件       下载路径："
		<< path << "    下载次数:" << cnt << "次" << endl;
}

运行图：