5

我有一个名为 Masterdocument 的类，其中包含不同的流程。每个过程包含不同数量的问题和每个问题的可能答案选项。文档中还提到了每个答案选项的权重。根据用户提供的答案，查阅主文档并对用户响应进行评分。示例代码如下所示。

Class Masterdocument {
vector <MasterProcess>;
}; 
Class MasterProcess1 { 
id = 10;
num of questions = 2;
question1;
answer1option1;
answer1option2;
question1Weightage;

question2;
answer2option1;
answer2option2;
question2weightage;

//constructor
MasterProcess1(){
question1 =1;
answer1option1 =1;
answer1 option2 = 2;
question1weightage = 0.1

question2 =2;
answer2option1 = 1;
answer2option2 = 2;
question2weightage = 0.2;
}
};

Class MasterProcess2 {
id  =11; 
num of questions = 3;
question1;
answer1option1;
answer1option2;
question1Weightage;

question2;
answer2option1;
answer2option2;
answer2option3;
question2weightage;

question3;
answer3option1;
answer3option2;
question3weightage;

//constructor
MasterProcess2(){
question1 =1;
answer1option1 =1;
answer1 option2 = 2;
question1weightage = 0.2

question2 =2;
answer2option1 = 1;
answer2option2 = 2;
answer2option3 = 3;
question2weightage = 0.3;

question3 = 3;
answer3option1 = 1;
answer3option2 = 2;
question3weightage = 0.4
}
};

MasterDocument 和所有 MasterProcesses 都是常量。值不会改变。但是每个过程的问题数量（以及每个问题的答案选项）不同。我可以使用构造函数初始化它们。但是我如何将它们添加到 MasterDocument 中的向量中，因为所有 MasterProcesses 都有不同的名称，例如 MasterProcess1、MasterProcess2 等等。所以我不能在 MasterDocument 中有一个向量。

如果我为每个进程使用相同的名称（每个进程都称为 MasterProcess），那么我怎么知道为第一个 MasterProcess 调用哪个构造函数，因为它有不同的问题数，然后是第二个 masterProcess。

我可以对主文档中的值进行硬编码，因为它不会改变，但我如何初始化这些值。我可以将所有流程放在单个 MasterDocument 中，并创建一个巨大的构造函数，其中包含每个流程的所有问题/答案，但这看起来并不漂亮。

我可以将每个进程称为 MasterProcess 并在构造函数中传递进程的 ID（如 MasterProcess (id)），但我将如何规定 MasterProcess(10) 应该调用第一类的构造函数，而 MasterProcess(11) 应该调用构造函数二等的。

@海森虫

我跟随你的脚步，想出了这段代码

#include <iostream>
#include <utility>
#include <string>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>

using namespace std;

class BaseMasterProcess {

protected:

int processID;  
int num_of_Questions;  
double min_Threshold_Score_for_Process;  
double total_Process_Score;  
double overall_Audit_Value;
int question;
pair <int,double> answer;

//define all the variable used in any sub-class 
int question1;
int question2;
int question3;
int question4;
int question5;
double question1_Weightage;
double question2_Weightage;
double question3_Weightage;
double question4_Weightage;
double question5_Weightage;
int passing_Score;
pair <int,double> answer1_Option1;  
pair <int,double> answer1_Option2; 
pair <int,double> answer1_Option3;
pair <int,double> answer2_Option1;  
pair <int,double> answer2_Option2; 
pair <int,double> answer2_Option3;
pair <int,double> answer3_Option1;  
pair <int,double> answer3_Option2; 
pair <int,double> answer3_Option3;
pair <int,double> answer4_Option1;  
pair <int,double> answer4_Option2; 
pair <int,double> answer4_Option3;
pair <int,double> answer5_Option1;  
pair <int,double> answer5_Option2; 
pair <int,double> answer5_Option3;

public:
abstract void Init();
virtual double getQuestionWeightage(int ques) = 0;
virtual double getAnswerScore(int ques, int ans) = 0; 
int getNumQuestions()
{
    return num_of_Questions;
}
int getProcesssID()
{
    return processID;
}
double getMinThresholdScore()
{
    return min_Threshold_Score_for_Process;
}
double overallAuditValue()
{
    return overall_Audit_Value; 
}
};
class ConcreteMasterProcess1 : public BaseMasterProcess
{
public:
    void Init()
    {
processID = 10; 
num_of_Questions = 3;  
passing_Score = 70;  
min_Threshold_Score_for_Process = 0.7; 
overall_Audit_Value = 0.1;

question1 = 1; 
question1_Weightage = 0.3;  
answer1_Option1 = make_pair (1,0.3); 
answer1_Option2 = make_pair (2,0.0);

question2 = 2; 
question2_Weightage = 0.3; 
answer2_Option1 = make_pair (1,0.3); 
answer2_Option2 = make_pair (2,0.0);


question3 = 3;
question3_Weightage = 0.4; 
answer3_Option1 = make_pair (1,0.4); 
answer3_Option2 = make_pair (2,0.0);
}

double getQuestionWeightage(int ques)
{
switch (ques)
{
    case 1:
        return question1_Weightage;
    case 2:
        return question2_Weightage;
    case 3:
        return question3_Weightage;
}
    }
double getAnswerScore(int ques, int ans) 
{
    if (ques == question1 && ans == answer1_Option1.first)
        return answer1_Option1.second;
    else if (ques == question1 && ans == answer1_Option2.first)
        return answer1_Option2.second; 
    else if (ques == question2 && ans == answer2_Option1.first)
        return answer2_Option1.second;
    else if (ques == question2 && ans == answer2_Option2.first)
        return answer2_Option2.second;
    else if (ques == question3 && ans == answer3_Option1.first)
        return answer3_Option1.second;
    else 
        return answer3_Option2.second;

}   
};
class ConcreteMasterProcess2 : public BaseMasterProcess
{
    void Init()
    {
processID = 11; 
num_of_Questions = 4;  
passing_Score = 70;  
min_Threshold_Score_for_Process = 0.75; 
overall_Audit_Value = 0.1;

question1 = 1; 
question1_Weightage = 0.25;  
answer1_Option1 = make_pair (1,0.25); 
answer1_Option2 = make_pair (2,0.0);

question2 = 2; 
question2_Weightage = 0.25; 
answer2_Option1 = make_pair (1,0.25); 
answer2_Option2 = make_pair (2,0.0);
answer2_Option3 = make_pair (3,0.15);

question3 = 3;
question3_Weightage = 0.25; 
answer3_Option1 = make_pair (1,0.25); 
answer3_Option2 = make_pair (2,0.0);

question4 = 4;
question4_Weightage = 0.2; 
answer4_Option1 = make_pair (1,0.2); 
answer4_Option2 = make_pair (2,0.0);

question5 = 5;
question5_Weightage = 0.2; 
answer5_Option1 = make_pair (1,0.2); 
answer5_Option2 = make_pair (2,0.0);
}

double getQuestionWeightage(int ques)
{
switch (ques)
{
    case 1:
        return question1_Weightage;
        break;
    case 2:
        return question2_Weightage;
        break;
    case 3:
        return question3_Weightage;
        break;
    case 4:
        return question4_Weightage;
        break;
}
    }
double getAnswerScore(int ques, int ans) 
{
    if (ques == question1 && ans == answer1_Option1.first)
        return answer1_Option1.second;
    else if (ques == question1 && ans == answer1_Option2.first)
        return answer1_Option2.second; 
    else if (ques == question2 && ans == answer2_Option1.first)
        return answer2_Option1.second;
    else if (ques == question2 && ans == answer2_Option2.first)
        return answer2_Option2.second;
    else if (ques == question2 && ans == answer2_Option3.first)
        return answer2_Option3.second;
    else if (ques == question3 && ans == answer3_Option1.first)
        return answer3_Option1.second;
    else if (ques == question3 && ans == answer3_Option2.first)
        return answer3_Option2.second;
    else if (ques == question4 && ans == answer4_Option1.first)
        return answer4_Option1.second;
    else
        return answer4_Option2.second;

}   
};
class MasterDocument
{
std::vector<BaseMasterProcess*> myProcessList;
void AddProcess(BaseMasterProcess* iProcess)
{
myProcessList.push_back(iProcess);
}
void foo()
{
//myProcessList[...]->Method1(); //do something without knowing which specific concrete    class the process belongs to..
}
};

int main ()
{
BaseMasterProcess bmp; 
ConcreteMasterProcess6 p6;  
MD master_doc;
master_doc.addProcess(bmp); // gives ERROR
    master_doc.addProcess(p6); // gives ERROR
master_doc.foo();

}

它给了我以下错误：

关于 Init() -> ISO C++ 禁止声明没有类型的“Init” [-fpermissive] 编辑：更改为 void Init() -> RESOLVED 关于函数 getQuestionWeightage(int) -> 在成员函数 'virtual double ConcreteMasterProcess1::getQuestionWeightage （int）'：错误：在'{'标记之前不允许函数定义 编辑：在开关末尾缺少}->已解决 关于main（）->预期'}'在输入末尾预期不合格输入末尾的 -id 编辑：在 mian() 中有额外的 } -> RESOLVED

如何解决 main() 中显示的错误。我要做的就是创建 MasterDocument 并在 myProcssList 中有两个具体流程？？？

4

2 回答 2

1

使用这样的结构。把它分解

MasterDocument{ 
vector <Process> 
... 
}; 
Process{ 
vector<Question>; 
... 
}; 
Question{ 
vector<Answer>: 
... 
}; 
Answer{ 
map<int answer, int score>;  
};
于 2012-05-07T21:21:49.787 回答
1

使用 shared_ptr 的另一个选项如下。

struct Answer {
int whatever;
}

struct Process {
int whatever;
std::vector<std::shared_ptr<Answer> > answers;
};

struct Document {
Document();
std::vector<std::shared_ptr<Process> > processes;
};
int main (){
Document::Document()
{
// Make some processes
for (int i = 0; i < 5; i++) {
std::shared_ptr<Process> foo = std::shared_ptr<Process>();
foo->whatever = i;
processes.push_back(foo);
}
}

}

于 2012-05-07T21:27:52.060 回答