Question

我有以下问题：我有一个名为algatorc的主要可执行程序。在这个程序中，我有一个名为TestCase，AbsAlgorithm和TestSetIterator的课程。最终用户必须创建新的algatorc程序，然后继承这三个类。

假设最终用户创建了项目排序。他最终会有三个名为SortingTestCase，SortingTestSetIterator和SortingAbsAlgorithm的课程。

所以这就是事情。最终用户有一个方法SortingTestSetIterator::get_current，此函数的返回类型为TestCase*。在此方法中，他创建SortingTestCase的实例并返回此实例。所以他实际上归还了TestCase的孩子。在我的主程序中，我将此指针保存到TestCase *t（不，我不能将其保存为SortingTestCase，因为在运行之前，我不知道项目的名称）然后我将此指针发送到方法SortingAbsAlgorithm::init(TestCase* test_case)。在这个特殊的方法中，最终用户可能会将此对象强制转换为他的（SortingTestCase），这样做是这样的：

sorting_test_case = dynamic_cast<SortingTestCase*>(test);

此SortingTestCase派生自TestCase，包含父类的所有成员和自己的两个变量：数组和大小。所以在init方法中我说

for (int i = 0; i<sorting_test_case->size; i++)
{
    std::cout << sorting_test_case[i] << std::endl;
}

然后我一无所获。看起来数组是空的。

知道我做错了什么吗？

编辑：

class SortingAbsAlgorithm : public AbsAlgorithm 
{
private: 
        SortingTestCase *sorting_test_case;
public:
        bool init (TestCase *test) 
        {
                sorting_test_case = dynamic_cast<SortingTestCase*>(test);
                std::cout << "INIT ARRAY" << std::endl;
                for (int i = 0; i<sorting_test_case->size; i++)
                {
                        std::cout << sorting_test_case->array_to_sort[i] << " ";
                }
        }
};

class SortingTestCase : public TestCase
{
public:
    int size;
    int *array_to_sort;

    void init_array(int tab[], int size)
    {
        array_to_sort = new int[size];
        for (int i = 0; i<size; i++)
        {
            array_to_sort[i] = tab[i];
        }
    }
};

class SortingTestSetIterator : public TestSetIterator
{
private:
    std::string file_path;
    std::string test_file_name;
public:

    TestCase *get_current()
    {
        if (current_input_line.empty())
        {
            return nullptr;
        }

        std::vector<std::string> fields;
        std::string token;
        std::stringstream str(current_input_line);
        while ( getline(str, token, ':') )
        {
            fields.push_back(token);
        }
        str.clear();

        if (fields.size() < 3)
        {
            report_invalid_data_format("to few fields");
            return nullptr;
        }

        std::string test_name = fields.at(0);
        int prob_size;
        try
        {
            prob_size = std::atoi(fields.at(1).c_str());
        } catch (...)
        {
            report_invalid_data_format("'n' is ot a number");
        }

        std::string group = fields.at(2);
        std::string test_id = "Test-" + std::to_string(line_number);
        EParameter *test_id_par = new EParameter("TestID", "Test identificator", test_id);
        EParameter *parameter1 = new EParameter("Test", "Test name", test_name);
        EParameter *parameter2 = new EParameter("N", "Number of elements", std::to_string(prob_size));
        EParameter *parameter3 = new EParameter("Group", "A name of a group of tests", group);

        SortingTestCase *t_case = new SortingTestCase();
        t_case->addParameter(*test_id_par);
        t_case->addParameter(*parameter1);
        t_case->addParameter(*parameter2);
        t_case->addParameter(*parameter3);

        int arr[prob_size];
        int i = 0;
        if (group == "INLINE")
        {
            if (fields.size() < 4)
            {
                report_invalid_data_format("to few fields");
                return nullptr;
            }
            std::vector<std::string> data;
            std::stringstream ss(fields.at(3));
            while (getline(ss, token, ' ') )
            {
                data.push_back(token);
            }

            if (data.size() != prob_size)
            {
                report_invalid_data_format("invalid number of inline data");
                return nullptr;
            }

            try
            {
                for (i = 0; i<prob_size; i++)
                {
                    arr[i] = std::atoi(data.at(i).c_str());
                }
            } catch (...)
            {
                report_invalid_data_format("invalid type of inline data - data " + std::to_string((i+1)));
                return nullptr;
            }
        }
        else if (group == "RND")
        {
            srand(time(NULL));
            for (i = 0; i<prob_size; i++)
            {
                arr[i] = rand() % prob_size + 1000;
            }
        }
        else if (group == "SORTED")
        {
            for (i = 0; i<prob_size; i++)
            {
                arr[i] = i;
            }
        }
        else if (group == "INVERSED")
        {
            for (i = 0; i<prob_size; i++)
            {
                arr[i] = prob_size - i;
            }
        }
        t_case->init_array(arr, prob_size);
        return t_case;
    }
};

这是最终用户类。我从这些课程中创建了库，然后通过dlopen和dlsym将其加载到我的程序中。我得到这样的类的实例：

#ifdef __cplusplus
extern "C" {
#endif
TestSetIterator * create_iterator_object() {
        return new SortingTestSetIterator;
}

void destroy_iterator_object(TestSetIterator* object) {
        delete object;
}
#ifdef __cplusplus
}

然后在我的主程序中加载符号create_iterator_object

create_it = (TestSetIterator* (*)())dlsym(handle, "create_iterator_object");

然后我这样说：

TestSetIterator *it = (TestSetIterator*)create_it();

我可以调用它 - ＆gt; get_current（）将文件加载到变量curent_input_line。所以我这样做：

TestCase *t_case = it->get_current();

然后我说

a->init(t_case)

a实际上SortingAbsAlgorithm加载与TestSetIterator（ofcourse，不同的符号）完全相同，并“保存”到AbsAlgorithm a*。

因此，当调用a->init(t_case)时，在此init最终用户投射t_case中，这是TestCase到SortingTestCase的类型。当我想在数组中打印元素时，数组是空的。

子类的成员是空的（多态）

0 个答案: