0

我正在考虑如何将功能依赖关系表示为数据结构。

（数据库的关系模式的）功能依赖性将一组属性映射到一组属性。例如，在 {A, B} -> {C, D} 中，属性 C 和 D 函数依赖于 A 和 B。

我可以在这里想到四种可能的情况：

  1. {A} -> {B}（两个单一属性）
  2. {A, B} -> {C}（一组属性意味着一个属性）
  3. {A} -> {B, C}（单个属性意味着一组属性）
  4. {A, B} -> {C, D}（一组属性意味着一组属性）

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

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

这适用于（1）之类的功能依赖项，但不适用于（2）-（4）-我认为。我确实可以分解 (3)，但我看不出用这样的类来表示 (2) 和 (4)。

我必须保留 C和D 在功能上依赖于 A和B 的信息，因此我必须创建一个类，例如attributegroup将一组属性映射到一组属性。例如：

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

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

任何帮助/想法表示赞赏:)

4

1 回答 1

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 适合示例数据。

于 2013-10-17T22:48:19.963 回答