C＋＋

Java

標準複製方式

賦值、拷貝構造

賦值，clone()

基本資料型別

包括整數，浮點數，布林值，字元，指標等，全部為值語義

包括整數，浮點數，布林值，字元等，全部為值語義

自定義型別

不包含資源的自定義型別，系統提供的預設拷貝建構函式與賦值操作符亦保證了值語義；包含資源的自定義型別，需要提供深拷貝操作的拷貝建構函式和賦值操作符，並在建構函式中獲取資源，在解構函式中釋放資源

沒有十分自然的方式將Java物件實現為值語義，通常採用“不可變類”的方式，如String，或遞迴實現深度clone()

C＋＋

Java

vector<int> first;

vector<int> second = first;

second.push_back(1000);

cout << first.size(); //0

cout << second.size();//1

String first = "abc";

String second = first;

first = first.replace('a', 'x');

System.out.println(first); //xbc

System.out.println(second);//abc 

C＋＋

Java

標準複製方式

賦值、拷貝構造

賦值，clone()

自定義型別

包含資源的自定義型別，沒有提供拷貝建構函式和賦值操作符，或者在拷貝建構函式和賦值操作符中有意共享資源，則此時的物件具有指標語義

預設全為指標語義，除非該類及其成員遞迴實現深度clone()，或實現為“不可變類”

C＋＋

Java

vector<int> obj(2, 0);

vector<int>::iterator first = obj.begin();

vector<int>::iterator second = first;

cout << *first; //0

cout << *second;//0

*first = 1;

cout << *first; //1

cout << *second;//1

List<Integer> first = newArrayList<Integer>();

List<Integer> second = first;

second.add(1000);

System.out.println(first.size()); //1

System.out.println(second.size());//1

我認為“值”與“物件”的區分在設計和實現時具有非常重要的指導作用，
因此下面做一些說明。

“值”與“物件”型別之間並沒有嚴格定義的區分。但通常可以觀察到下列不同：

0. “值”是“死的”、“傻的”、“簡單的”、“具體的”、“可複製的”，
“物件”是“活的”、“聰明的”、“複雜的”、“抽象的”、“不可複製的”。

這裡的“複雜性”主要還是指行為的複雜性，而非結構的複雜性。例如，

list< map< vector<string>, deque< set<int> > > >

仍然是一個不折不扣的“值”型別。

這裡我們不在哲學的路上走太遠，還是看看下面更具體的一些特徵吧。

1. “值”的成員函式(包括解構函式)都不是 virtual 的，不是設計來被繼承的。
“物件”的解構函式是 virtual 的，而且通常還有其它的 virtual 成員函式，
是設計來被繼承的，或繼承了其他基類。

// value:
struct String {
// non-virtual destructor:
~String() { delete[] s_; }
private:
char* s_;
};

// string should not be public-ly inherited.

// object:
struct OutputDevice {
virtual ~OutputDevice();
virtual void output( char const* ) = 0;
};

struct ConsoleOutputDevice : OutputDevice {
// inherits virtual destructor,
// overrides virtual member function:
void output( char const* );
};

2. “物件”經常必須通過指標或引用來使用，“值”不一定需要。

::std::auto_ptr<OutputDevice> output( new ConsoleOutputDevice() );

void f( OutputDevice& dev )
{
// ...
dev.output( "blah blah/n" );
// ...
}

String s = "dsjflsdjflsjlf";
String t = "djslfdsjfsl";
s += t;

void g( String s ) // by-value is OK.
{
// ...
}

g( s );


3. “值”可以複製出任意多份等價物，是 Assignable, CopyConstructible 的
(C++標準裡定義了Assignable, CopyConstructible 的具體含義)。
“物件”通常不是 Assignable 也不是 CopyConstructible 的，通常是被共享的
不是被複制的。 即使“物件”被“克隆”，“克隆”出來的物件與原物件也不是
完全等價的：相同的基因，不同的個體。

string s = "dsjlfsdjlfsdjlfsdjl";
string t;
t = s;
// the following two lines are equivalent:
cout << s;
cout << t;

auto_ptr<OutputDevice> dev1( new ConsoleOutputDevice(...) );
auto_ptr<OutputDevice> dev2( dev1.clone() );
// the following two lines are NOT equivalent:
dev1->output( "blah blah" );
dev2->output( "blah blah" );

這裡，dev2 可能具有與 dev1 相同的位置、大小、許可權等屬性，但卻是
完全不同的另一個視窗。

4. 對於“值”型別，應該嚴格保證 constness-correctness，對於“物件”型別，
通常不需要，甚至有些 'const' 是有害的。

// bad design of a value type:
struct Contact {
string address(); // non-const
};

void f( Contact const& contact )
{
cout << contact.address(); // won't compile.
}

// maybe bad design of an intelligent object type:
struct Robot {
string name( Object const& asker ) const // const!
{ return my_name; }
private:
string my_name;
};

由於 Robot 的智慧，問他一次名字也可能要觸發它內部狀態的改變。
一般來說，我們不應該對一個複雜“物件”假設任何操作不改變其內部狀態，
因此其介面上不應有 const 成員函式。 使用一個 const Robot
也是毫無意義的。如果你覺得 Robot 比較特殊，可以想想 const Database。

5. “值”是可以比較的，“物件”通常是不可比較的，要比較的話，
應該比較物件的地址，而不是內容。

根據“值”型別表達的概念的特點，比較關係運算可分為兩個層次：

a 相等性比較：

bool operator == ( T const& ) const;
bool operator != ( T const& ) const
{ return ! operator == ( other ); }

而且 operator !=( other ) 必須等價於 ! operator == ( other )，
operator == () 必須是一個“等價關係”(equivalence relationship):
任給 T a, b, c:

(自反的) (a == a) => true.
(對稱的) (a == b) => (b == a).
(傳遞的) (a == b && b == c) => (a == c).

對於一個型別 T 的兩個物件 a, b，如果表示式 (a == b) 可以轉換為
bool 型別，而且這個 operator == () 是 T 上的一個等價關係，那麼
就說 T 是 EqualityComparable 的。

b 排序關係比較：

bool operator < ( T const& ) const;
bool operator > ( T const& other ) const
{ return other < *this; }
bool operator >= ( T const& other ) const
{ return ! operator < ( other ); }
bool operator <= ( T const& other ) const
{ return ! operator > ( other ); }

這些運算之間的關係必須滿足上面給出的實現所表達的等價性。
(因此通常只實現 operator<()，然後從這裡 copy 另外三個！)
operator <() 必須是 T 上的一個“嚴格弱序”
(strict weak ordering)關係：

任給 T a, b, c:

(irreflexive) (a < a) => false.
(transitive) (a < b && b < c) => (a < c).
(weak ordering)
定義 eqiv(a,b) = ! (a < b) && ! (b < a).
equiv(a,b) && equiv(b,c) => eqiv(a,c).

這樣，operator<() 可以在 equiv 決定的 T 的等價類上定義一個全序
(total ordering).

對於一個型別 T 的兩個物件 a, b，如果表示式 (a < b) 可以轉換為
bool 型別，而且這個 operator < () 是 T 上的一個嚴格弱序關係，
那麼就說 T 是 LessThanComparable 的。

一個“值”型別可以只實現相等性比較。如果同時實現了排序關係比較，
那麼必須有 (a == b) iff (! (a < b) && ! (b < a))。

上述對關係運算的要求來自於 C++ 標準中對容器類中物件的要求。即使
你的型別的物件不被放到標準容器中，也應該滿足上述要求，否則就可能
產生一些讓他人吃驚的行為。

綜上所述，在設計一個類時，如果思考一下這個類表達的是一個簡單的“值”
還是一個複雜的“物件”，非常有助於決定類的介面以及用法的許多方面：

. 會不會被繼承/有沒有 virtual 函式？
. 是否允許拷貝和賦值？還是必須共享/克隆？
. 如何對待 constness-correctness？
. 是否應該實現比較運算？實現哪些？

等等等等。

(除了“值”和“物件”的區分外，還有一批C++中的型別可以歸類為
表達了一個“概念”，但那是另一個話題)

"三月的外星人" <[email protected]> 寫入訊息
news:[email protected]
> 標準中一些具體的類是否都應當看作是“值”類，比如“map",list,vector等？
> 而一些抽象的類就可以看成是”物件“類？

標準的資料型別大致有以下幾類：

“值”:

各種基本型別：int, double, ...。各種指標。complex<>。
各種容器: vector<>, list<>, multi/set<>, multi/map<>, deque<>,
bitset<>, basic_string<>, valarray<>... 以及它們的各種 iterator。
adaptors: stack<>, queue<>, priority_queue<>。
各種 functor: less, greater, equal_to, plus, minus, binder1st...。
locale 是把“物件”型別通過共享方式包裝成“值”型別，以方便使用。


“物件”：

iostream相關類：basic_ios<>, basic_*stream<>, basic_*streambuf<>。
各種facet: ctype_base/ctype<>, codecvt_base/codecvt<>...。
type_info。


“值與物件的混合物”

異常類：exception，bad_exception, logic_error, range_error...。
可以象“值”一樣複製，但又有繼承層次，可以通過基類(exception)
引用或指標來使用。這種設計在應用程式裡最好避免，因為很容易引起
object-slicing:

exception e = domain_error( "sqrt(NegativeNumber)" );

上面一行能編譯，能執行，但沒有做想讓它做的事。


“概念實現”：(象“值”一樣簡單，但不是用來裝一個“值”的)

iterator<>, input_iterator_tag, output_iterator_tag...,
unary_function<>, binary_function<>...。


“特徵描述”

iterator_traits<>, char_traits<>, numeric_limits<>...。


“怪物”：

auto_ptr<>。