java - C++从Java角度设置和映射内存管理

Question

我有 Java 背景。 (Hash-) maps 和 sets 是我在工作过程中每天要打交道的东西。当谈到 C++(或一般手动管理的内存)时，我想知道如何正确地使用它们。

根据定义，当将对象添加到集合/映射时，只有当它/标识符不在其中时才会添加。所以调用 Add()/Put() 的函数不能在添加对象后销毁对象(否则损坏的指针将保留在集合中)，它必须销毁它如果因为在集合中发现了一个相等的对象(或者会出现内存泄漏)而没有添加它，并且如果在集合中发现了一个相等的对象恰好是试图添加的对象，则它不能销毁它.创建深层拷贝实际上是不可能的(或者我不清楚如何创建)，因为在我的情况下数据对象可能递归地相互依赖。

当从一个集合中获取一个子集时(比如包含 foos 和 bars 的集合中的所有 bars)，并且原始集合被释放，所有的 foos 都必须被释放，而包含在子集中的 bars 不能被释放。如果集合被释放，它们必须被释放，但前提是它们不再被任何其他集合使用。如果一组长柱也从原始集合派生出来，而这组柱不知道，甚至可能在不同的线程中，该怎么办？

为了说明这个问题，下面是一个用 Java 编写的最小示例，用于管理内存中链接数据的小记录。下面的 main() 方法显示了它的一些用例可能性。

interface IObject { }

interface INode extends IObject { }

interface IIdentifiable extends IObject {
    String m_csSubject();
}

class CLiteral implements IObject {
    private String m_csValue;
    CLiteral(String csValue) { m_csValue = csValue; }
    String m_csValue() { return m_csValue; }

    public int hashCode() {
        return 31 * 1 + ((m_csValue == null) ? 0 : m_csValue.hashCode());
    }

    public boolean equals(Object cObject) {
        if (this == cObject) return true;
        if (cObject == null) return false;
        if (getClass() != cObject.getClass()) return false;
        CLiteral cOther = (CLiteral) cObject;
        if (m_csValue == null) {
            if (cOther.m_csValue != null) return false;
        } else if (!m_csValue.equals(cOther.m_csValue)) return false;
        return true;
    }
}

class CLangString extends CLiteral {
    private final String m_csLanguage;
    CLangString(String csValue, String csLanguage) {
        super(csValue);
        m_csLanguage = csLanguage;
    }

    public int hashCode() {
        return 31 * super.hashCode() + ((m_csLanguage == null) ? 0 : m_csLanguage.hashCode());
    }

    public boolean equals(Object cObject) {
        if (this == cObject) return true;
        if (!super.equals(cObject)) return false;
        if (getClass() != cObject.getClass()) return false;
        CLangString cOther = (CLangString) cObject;
        if (m_csLanguage == null) {
            if (cOther.m_csLanguage != null) return false;
        } else if (!m_csLanguage.equals(cOther.m_csLanguage)) return false;
        return true;
    }
}

class CLink implements IIdentifiable, INode {
    private String m_csSubject;

    CLink(String csSubject) { m_csSubject = csSubject; }
    public String m_csSubject() { return m_csSubject; }

    public int hashCode() {
        return 31 * 1 + ((m_csSubject == null) ? 0 : m_csSubject.hashCode());
    }

    public boolean equals(Object cObject) {
        if (this == cObject) return true;
        if (cObject == null) return false;
        if (getClass() != cObject.getClass()) return false;
        CLink cOther = (CLink) cObject;
        if (m_csSubject == null) {
            if (cOther.m_csSubject != null) return false;
        } else if (!m_csSubject.equals(cOther.m_csSubject)) return false;
        return true;
    }
}

import java.util.*;
import java.util.Map.Entry;
class CNode implements INode {
    static final String m_csTYPE = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
    final Map<String, Collection<IObject>> m_cEdges = new HashMap<>();

    CNode() { }
    CNode(CLink cType) { put(m_csTYPE, cType); }
    CNode(String csType) { this(new CLink(csType)); }

    CResult get(String csPredicate) {
        CResult cResult = new CResult();
        cResult.addAll(m_cEdges.get(csPredicate));
        return cResult;
    }

    CResult getById(String csPredicate, String csIdPredicate, String csIdValue) {
        CResult cResult = new CResult();
        for (Entry<String, Collection<IObject>> cEntry : m_cEdges.entrySet())
            for (IObject cValue : cEntry.getValue())
                if (cValue instanceof CNode) {
                    CNode cNode = (CNode) cValue;
                    if (cNode.hasType(csPredicate) && cNode.get(csIdPredicate).Strings().contains(csIdValue))
                        cResult.add(cNode);
                }
        return cResult;
    }

    boolean hasType(String csType) {
        for (IIdentifiable cIdentifiable : get(m_csTYPE).iIdentifiables())
            if (csType.equals(cIdentifiable.m_csSubject())) return true;
        return false;
    }

    <T extends CNode> T put(String csPredicate, IObject cObject) {
        Collection<IObject> cObjects = m_cEdges.get(csPredicate);
        if (cObjects == null) m_cEdges.put(csPredicate, cObjects = new HashSet<>());
        cObjects.add(cObject);
        return (T) this;
    }
}

class CNamedNode extends CNode implements IIdentifiable {
    private String m_csSubject;

    CNamedNode(String csSubject, CLink cType) {
        super(cType);
        m_csSubject = csSubject;
    }

    public String m_csSubject() { return m_csSubject; }

    public int hashCode() {
        return 31 * 1 + ((m_csSubject == null) ? 0 : m_csSubject.hashCode());
    }

    public boolean equals(Object cObject) {
        if (this == cObject) return true;
        if (cObject == null) return false;
        if (getClass() != cObject.getClass()) return false;
        CNamedNode cOther = (CNamedNode) cObject;
        if (m_csSubject == null) {
            if (cOther.m_csSubject != null) return false;
        } else if (!m_csSubject.equals(cOther.m_csSubject)) return false;
        return true;
    }
}

import java.util.*;
class CResult extends HashSet<IObject> {
    Set<CNamedNode> CNamedNodes() {
        Set<CNamedNode> cResult = new HashSet<>();
        for (IObject cMember : this)
            if (cMember instanceof CNamedNode) cResult.add((CNamedNode) cMember);
        return cResult;
    }

    Set<CNode> CNodes() {
        Set<CNode> cResult = new HashSet<>();
        for (IObject cMember : this)
            if (cMember instanceof CNode) cResult.add((CNode) cMember);
        return cResult;
    }

    Set<IIdentifiable> iIdentifiables() {
        Set<IIdentifiable> cResult = new HashSet<>();
        for (IObject cMember : this)
            if (cMember instanceof IIdentifiable) cResult.add((IIdentifiable) cMember);
        return cResult;
    }

    boolean IsAnyIdentifiable() {
        boolean bResult = false;
        for (IObject cMember : this) if (cMember instanceof IIdentifiable) return true;
        return bResult;
    }

    String String() {
        StringBuilder cResult = new StringBuilder();
        boolean bFirst = true;
        for (String csString : Strings()) {
            if(bFirst) bFirst = false; else cResult.append(", ");
            cResult.append(csString);
        }
        return cResult.toString();
    }

    Set<String> Strings() {
        Set<String> cResult = new HashSet<>();
        for (IObject cMember : this)
            if (cMember instanceof CLiteral) cResult.add(((CLiteral) cMember).m_csValue());
        return cResult;
    }
}

public static void main(String[] args) {
    final String m_csNS = "http://animalShelter.example/";
    CResult cDogs;
    CResult cFidos;
    {
        CNode cShelter = new CNode(m_csNS + "AnimalShelter");
        cShelter.put(
            m_csNS + "hasDog",
            new CNode(new CLink(m_csNS + "Dog"))
                .put(m_csNS + "hasName", new CLangString("Fido", "en"))
                .put(m_csNS + "residence", cShelter)
        );
        cShelter.put(
            m_csNS + "hasDog",
            new CNamedNode(
                "http://en.wikipedia.org/wiki/Scooby-Doo_(character)", new CLink(m_csNS + "Dog")
            )
                .put(m_csNS + "hasName", new CLangString("Scoobert \"Scooby\" Doo", "en"))
                .put(m_csNS + "residence", cShelter)
        );

        cDogs = cShelter.get(m_csNS + "hasDog");
        cFidos = cShelter.getById(m_csNS + "Dog", m_csNS + "hasName", "Fido");
    }

    if(!cDogs.isEmpty()){
        System.out.println("No. of dogs: " + cDogs.size());
    }
    if (cDogs.IsAnyIdentifiable()) {
        System.out.println("Famous dogs:");
        for (CNamedNode cWellKnownDog : cDogs.CNamedNodes()) {
            System.out.println("- " + cWellKnownDog.get(m_csNS + "hasName").String() + " ("
                    + cWellKnownDog.m_csSubject() + ')');
        }
    }

    if(!cFidos.isEmpty()){
        System.out.println(cFidos.CNodes().size() + " dog(s) called Fido.");
    }
}

我如何对 C++ 执行此操作？如何在我的数据模型类中实现对象销毁，使使用它的函数(在本例中为 main())不(或最不可能)关心模型的内部结构？

Answer 1

插入 C++ HashMap /集合(std::unordered_map 和 std::unordered_set)是通过复制来完成的。那应该是您的默认选择。不要试图像编写 Java 那样编写 C++。

如果您想避免深度复制，您的映射/集合可以包含指向对象的原始指针，但对象的生命周期是单独维护的(例如，在 std::vector 中)。

但是，可能有理由需要更多类似 Java 的语义。例如，您可能希望映射/集合拥有多态类型。在那种情况下，您可能需要智能指针。最好拥有唯一的所有权(只有一个智能指针拥有每个对象)，在这种情况下，您可以使用 std::unique_ptr 或者如果您必须拥有共享所有权，请使用 std: :shared_ptr。这两种智能指针都可以存储在 std::unordered_map 或 std::unordered_set 中，并且应该大致具有您期望的语义。