Question

我来自Java背景。（Hash-）地图和集合是我在工作过程中每天处理的内容。谈到C ++（或一般的手动管理内存），我想知道如何正确使用它们。

根据定义，在将对象添加到集合/映射时，只有在它/标识符不存在的情况下才会添加它。所以调用Add() / Put()的函数在添加之后不得销毁该对象（或者一个破坏的指针将保留在集合中），如果没有添加它，它必须销毁它，因为相同的对象是在集合中找到（或者存在内存泄漏），如果在集合中发现了一个恰好是试图添加的对象的相等对象，它就不能销毁它。创建深层副本实际上是不可能的（或者我不清楚如何），因为在我的情况下，数据对象可能以递归方式相互依赖。

当从集合中获取子集（假设包含foos和bar的集合中的所有条形图），并且原始集合被释放时，所有foos必须被释放，而子集中包含的条带不能被释放。如果集合被释放，它们必须被释放，但前提是它们不再用于任何其他集合。如果从原始集合中导出了一组长条，并且这组条形图不知道，甚至可能在不同的线程中，该怎么办？

为了说明问题，这里是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 ++哈希映射/集（std::unordered_map和std::unordered_set）是通过复制完成的。那应该是你的默认选择。不要像编写Java那样尝试编写C ++。

如果你想避免深度复制，你的map / set可以包含对象的原始指针，但是对象的生命周期是单独维护的（例如在std::vector中）。

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

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

1 个答案: