Question

我正在考虑如何在数据结构中表示功能依赖。

功能性depdendency（数据库的关系模式）将一组属性映射到一组属性。例如。在{A，B}中 - ＆gt; {C，D}属性C和D的功能取决于A和B.

我可以在这里考虑四种可能的情况：

{A} - ＆gt; {B}（两个单一属性）
{A，B} - ＆gt; {C}（一组属性意味着一个属性）
{A} - ＆gt; {B，C}（单个属性意味着一组属性）
{A，B} - ＆gt; {C，D}（一组属性意味着一组属性）

我的第一个方法是一个简单的两个成员类：

class attribute
{
    string name;
    set<attribute*> dependent_on;
}

这适用于功能依赖，如（1）但不适用于（2） - （4） - 我认为。事实上，我可以分解（3），但我认为无法用这样的类来表示（2）和（4）。

我必须保留C 和 D的功能依赖于A 和 B的信息，所以我必须创建一个像attributegroup这样的类一组属性映射到一组属性。 E.g：

class attributegroup
{
    set<attribute*> members;
    set<attribute*> dependent_on;
}

所以实际上我只能将一个属性表示为只有一个成员的attributegroup。但我不认为这是最好的方法。

任何帮助/想法赞赏：）

Answer 1

我不会将依赖项存储在属性中：

include <iostream>
#include <map>
#include <vector>

struct Attribute;
typedef std::vector<Attribute> Attributes;
struct Attribute {
    char name;
    operator Attributes () const { return Attributes{ 1, *this }; }
};

inline bool operator < (const Attribute& a, const Attribute& b) {
    return a.name < b.name;
}

inline bool operator < (const Attributes& a, const Attributes& b) {
    return std::lexicographical_compare(
        a.begin(), a.end(),
        b.begin(), b.end());
}

inline std::ostream& operator << (std::ostream& stream, const Attributes& attributes) {
    for(const auto& a: attributes) {
        std::cout << a.name;
    }
    return stream;
}

typedef std::multimap<Attributes, Attributes> AttributeDependencies;
typedef AttributeDependencies::value_type AttributeDependency;

int main(int argc, const char* argv[]) {
    Attribute a {'A'};
    Attribute b {'B'};
    Attribute c {'C'};
    Attribute d {'D'};

    AttributeDependencies dpendencies;
    dpendencies.insert(AttributeDependency(a, b));
    dpendencies.insert(AttributeDependency(Attributes{a, b}, c));
    dpendencies.insert(AttributeDependency(a, Attributes{b, c}));
    dpendencies.insert(AttributeDependency(Attributes{a, b}, Attributes{c, d}));
    for(const auto& d: dpendencies) {
        std::cout << '{' << d.first << "} -> {" << d.second << "}\n";
    }
    return 0;
}

注意：std :: map可能是正确的容器，但std :: multimap符合示例数据。

用于表示功能依赖性的数据结构

1 个答案: