集合如何区分对象？

Question

How does a set differentiate between objects in both Java and C++? Or do sets not differentiate them at all?

Take these for example:
C++

std::set<A> aset;
A a(1, 2); // Assume A has only two elements, and this constructor sets them both
aset.insert(a);
A a2(1, 2); // This would initialise a `A' object to the same values as `a', but a different object
aset.count(a2); // Would this return 1 or 0?

Java

set<A> aset;
A a = new A(1, 2); // Assume A has only two elements, and this constructor sets them both
aset.add(a);
A a2 = new A(1, 2); // This would initialise a `A' object to the same values as `a', but a different object
aset.contains(a2); // Would this return true or false?

Answer 1

In C++ the set depends on operator<() being defined for the class A, or that you supply a comparison object providing strict weak ordering to the set.

Answer 2

For Java it depends on the equals, hashcode contract.

Answer 3

For the Java part, The method in charge of determining whether two objects are equal is:

public boolean equals(Object other)

Not to be confused with

public int hashCode()

Whose contract states that two equals objects must return the same number, but two objects that returned the same number may be, but are not necessarily, equal.

The default implementation for the equals method is equality by memory address, therefor if class A did not override the equals method the contains method will return false.

To have the set.contains(a2) method return true you must override the equals and hashCode method to comply as so:

public boolean equals(Object other) {
  return other instanceof A && ((A) other).elem1 = this.elem1 && ((A) other).elem2 =    this.elem2; 
}
public int hashCode() {
    return elem1 * 31 + elem2;
}

The hashCode is required (assuming you're using a HashSet) for the set to identify where in the internal representation of the set the object may be (ie where to look for it). Search for HashSet\HashMap to understand the internal representation if you're interested.

As for the C++ part, If I remember correctly it depends on the correct operator overloading, but my C++ is rusty at best.

EDIT: I noticed you specifically asked about sets so I'll elaborate a bit more on how that: While the equals method is what determines equality between two objects, some preliminary steps in the set implementation used (eg HashSet or TreeSet) might relay on something extra:

For example, the HashSet uses the hashCode() function to find the internal location the item might be in, so if A did not override/correctly implement the hashCode() function, the set.contains(a2) may return true or false (for default implementation it's non deterministic - depends on memory location and the current capacity of the set).

For a TreeSet internal implementation to correctly find items within it either the items contained must be implement the Comparable interface properly or the TreeSet itself must be supplied with a Comparator instance implemented properly.

Answer 4

In Java at least, comparison is done on a hash code, which by default is created from the location of the object in memory. So in the Java part of the question, aset.contains(a2); would return false, as a2 points to a different part of the memory to a .

I'm afraid I can't comment on how C++ works!

Answer 5

for C++, according to set::insert in C++ Reference

Because set containers do not allow for duplicate values, the insertion operation checks for each element inserted whether another element exists already in the container with the same value, if so, the element is not inserted and -if the function returns a value- an iterator to it is returned

.

They check for the values, unlike Java, which only checks for the address instead.

Answer 6

Java calls the object's equals method, which, if you haven't overridden it, is the same as calling Object.hashCode() .