使用集合存储自定义类，只有第一个插入有效

Question

基本问题 请阅读此问题，即使您没有时间查看所有其他详细信息。 :) - 我需要将我的自定义类（元组）的多个对象存储到一个集合中。该类仅包含一个字符串向量。 （根据项目要求）。我如何实现这一点，以便它唯一地识别每个元素（因此只消除相同的向量）？ 2 - 我的教授建议我可以从自定义类（元组）中的向量字符串继承，这样我就不必编写自己的“运算符

• 1 - 这是真的吗？
• 2 - 如果没有，我是否可以使用继承来获得此功能？

更多细节，如果你有时间:)

我在网上看了一会儿，还没有找到解决问题的方法。首先，我承认这是一项学校作业（一个简单的关系数据库），所以我有一些要求要遵循（即使我现在不明白为什么要这样做）。

• 必修课

• --> “关系” ------> 必须使用 std::set 来保存元组

• -->“元组” ------> 是“属性值”的列表

我在课堂上得到提示，如果我扩展字符串向量，我不会在“元组”类中编写自己的运算符

问题： 我需要存储一组“元组”我要创建的类。我现在遇到的问题是只存储了第一个“元组”。我在集合旁边使用了一个向量，这样我就可以查看我的代码是否正在尝试做我想做的事情，看起来我的问题是集合正在识别我插入的每个“元组”等同于已经存在的“元组” ，因此我最终得到了一组只有 1 个“元组”，即使我应该有更多。

我在下面包含了我认为相关的代码。为了不让你看太多东西，在底部我展示了将新的“元组”插入到已经存在的“关系”中的函数，如果你查看 Relation 类，你会看到函数“insertTuple(Tuple tupIn);"它接收一个元组并将其添加到相关集合中。

我需要知道什么？

• 为什么集合中只存储一个项目？
• 如何解决此问题，以便所有非重复项目都存储在集合中？ （假设我并不是所有的插入都是重复的，因为它们不是）。

感谢 StackOverflow，你们是一群聪明、有耐心的人！

元组.h

 #include <iostream>
 #include <vector>
 #include "DatalogProgram.h"
 using namespace std;


 class Tuple : public vector<string>
 {
 private:
     vector<string> attributevals;
 public:
     Tuple();
     Tuple(Predicate input);
     ~Tuple();
     vector<string> returnAttributeVals();
     string toString();
 };

元组.cpp

 #include "Tuple.h"
 Tuple :: Tuple()
 {

 }
 Tuple :: Tuple(Predicate input)
 {
     // Here I will populate the tuple!
     attributevals.clear();
     for(int x = 0; x < input.returnParams().size(); x++)
     {
         //cout << "Adding value to Tuple: " << endl;
         //cout << input.returnParams().at(x).toString() << endl;
         attributevals.push_back(input.returnParams().at(x).toString());
     }
 }
 Tuple :: ~Tuple()
 {
     attributevals.clear();
 }
 vector<string> Tuple :: returnAttributeVals()
 {
     return attributevals;
 }

 string Tuple :: toString()
 {
     string value = "";
     for(int x = 0 ; x < attributevals.size() ; x++)
     {
         value = value + attributevals.at(x) + " -|- ";
     }
     return "Attribute Values : \n" + value;
 }

关系.h

 #include <iostream>
 #include <set>
 #include <vector>
 #include <string>
 #include "Scheme.h"
 #include "Tuple.h"
 //#include "DatalogProgram.h"
 #pragma once
 using namespace std;

 class Relation
 {
 private:
     string Rname;
     Scheme Rscheme;
     set<Tuple> Rtuples;
     vector<Tuple> RtempVec;
 public:
     Relation(string nameIn, Scheme schemeIn);
     Relation(string nameIn, Scheme schemeIn, set<Tuple> tuplesIn);
     ~Relation();
     void insertTuple(Tuple tupIn);
     void select();
     void project();
     void rename();
     void testOutput();
     string returnName();
     Scheme returnScheme();
     set<Tuple> returnTuples();
     string toString();
 };

关系.cpp #include "Relation.h"

 Relation :: Relation(string nameIn, Scheme schemeIn)
 {
     Rname = nameIn;
     Rscheme = schemeIn;
 }
 Relation :: Relation(string nameIn, Scheme schemeIn, set<Tuple> tuplesIn)
 {
     Rname = nameIn;
     Rscheme = schemeIn;
     Rtuples = tuplesIn;
 }
 Relation :: ~Relation()
 {
     Rname.clear();
     Rscheme.clear();
     Rtuples.clear();
 }
 void Relation :: insertTuple(Tuple tupIn)
 {
     cout << Rname << "  ->  Inserting the following Tuple :  \n" << tupIn.toString() << endl;
     Tuple temp = tupIn;
     Rtuples.insert(temp);
     cout << "Current # of tuples in this relation" << Rtuples.size() << endl;
     RtempVec.push_back(temp);
 }
 string Relation :: returnName()
 {
     return Rname;
 }
 Scheme Relation :: returnScheme()
 {
     return Rscheme;
 }
 set<Tuple> Relation :: returnTuples()
 {
     return Rtuples;
 }
 string Relation :: toString()
 {
cout << "Printing Relation " + Rname << endl;
cout << "Number of Tuples: " << Rtuples.size() << endl;
cout << "Number of tuples in temp Vector" << RtempVec.size() << endl;
set<Tuple> temp = Rtuples;
string result = "";
result = Rname + "\n" + Rscheme.toString() + "\n";
std::set<Tuple>::iterator setiter;
for(setiter = Rtuples.begin(); setiter!=Rtuples.end();setiter++)
{
    cout << "looping through tuples" << endl;
    Tuple temp = *setiter;
    result = result + " " + temp.toString() + "'\n";

}
return result;
 }
 void select();
 void project();
 void rename();
 void testOutput();

现在我已经包含了比任何人都想看的更多的代码，但这里是创建我试图插入到关系中的元组的函数（进入集合）。

 void Database :: ProcessFacts(vector<Predicate> input)
 {
     // So for facts I need to match the ID, then add the Paramaters to the tuple in the relation.
     // this means I itterate through the Relations already present, if it maches then I add a tuple!
     for (int x = 0; x < Drelations.size(); x++)
     {
         for(int y = 0; y < input.size() ; y++)
         {
             if(input.at(y).returnID() == Drelations.at(x).returnName())
             {
                 cout << "adding a tuple to  -->  " << Drelations.at(x).returnName() << endl;
                 cout << "Tuple is: " << Tuple(input.at(y)).toString() << endl;
                 Drelations.at(x).insertTuple(Tuple(input.at(y)));
             }
         }
     }
 }

Answer 1

问题是您从向量继承以避免编写自己的运算符

从标准容器继承是可行的，但这并不总是最好的主意，因为它们没有虚拟析构函数。对于这个作业应该没问题，但你应该做一些研究，以便了解未来的问题。

这是一个示例，它演示了您当前代码的问题，并显示了使用继承和成员向量的两个替代方案。我推荐成员向量，因为它避免了从标准容器继承的问题，并且 operator

#include <cstdlib>
#include <iostream>
#include <set>
#include <string>
#include <vector>

class ProblemTuple : public std::vector<std::string>
{
public:
    void AddAttribute(const std::string& item)
    {
        attributes.push_back(item);
    }

    void Print() const
    {
        for(const std::string& a : attributes)
        {
            std::cout << a << " ";
        }
        std::cout << "\n";
    }
private:
    std::vector<std::string> attributes;
};

class InheritedTuple : public std::vector<std::string>
{
public:
    void AddAttribute(const std::string& item)
    {
        push_back(item);
    }

    void Print() const
    {
        for(const std::string& a : *this)
        {
            std::cout << a << " ";
        }
        std::cout << "\n";
    }
};

class CompositeTuple
{
public:
    void AddAttribute(const std::string& item)
    {
        attributes.push_back(item);
    }

    void Print() const
    {
        for(const std::string& a : attributes)
        {
            std::cout << a << " ";
        }
        std::cout << "\n";
    }

    bool operator<(const CompositeTuple& rhs) const
    {
        return attributes < rhs.attributes;
    }

private:
    std::vector<std::string> attributes;
};

std::string randomString()
{
    std::string ret;
    for(int i = 0; i < 3; ++i)
    {
        ret += 'a' + (std::rand() % 26);
    }
    return ret;
}

template<typename T>
void PrintSet(const std::string& title, const std::set<T>& set)
{
    std::cout << title << "\n";
    for(const auto& s : set)
    {
        std::cout << "   ";
        s.Print();
    }
}

int main()
{
    //Not calling srand on purpose so the result should be the same every time.
    std::set<ProblemTuple> ProblemSet;
    std::set<InheritedTuple> InheritedSet;
    std::set<CompositeTuple> CompositeSet;

    for(int i = 0; i < 3; ++i)
    {
        ProblemTuple pt;
        InheritedTuple it;
        CompositeTuple ct;
        for(int j = 0; j < 3; ++j)
        {
            std::string s(randomString());
            pt.AddAttribute(s);
            it.AddAttribute(s);
            ct.AddAttribute(s);
        }
        ProblemSet.insert(pt);
        InheritedSet.insert(it);
        CompositeSet.insert(ct);
    }

    PrintSet("Problem", ProblemSet);
    PrintSet("Inherited", InheritedSet);
    PrintSet("Composite", CompositeSet);

    return 0;
}