例一：

 1 #include<iostream>
 2 using namespace std;
 3 class numbered{
 4 private:
 5     static int seq;
 6 public:
 7     numbered(){ mysn = seq++;}
 8     int mysn;        
 9 }; 
10 int numbered::seq = 0;
11 
12 void f(numbered s){
13     cout<<s.mysn<<“ ”;
14 }
15 int
 
 main(int argc,char**argv){
16     numbered a,b=a,c=b;
17     f(a);  f(b);  f(c); 
18     return 0 ; 
19 }

輸出 0 0 0

例二：

 1 #include<iostream>
 2 using namespace std;
 3 class numbered{
 4 private:
 5     static int seq;
 6 public:
 7     numbered(){ mysn = seq++;}
 8     numbered(numbered &n) { mysn = seq++;}
 
 9     int mysn;        
10 }; 
11 int numbered::seq = 0;
12 
13 void f(numbered s){
14     cout<<s.mysn<<endl;
15 }
16 int main(int argc,char**argv){
17     numbered a,b=a,c=b;
18     f(a);  f(b);  f(c); 
19     return 0 ; 
20 }

輸出 3 4 5

定義變數a時，預設建構函式起作用，序號設定為0，當定義b,c時，拷貝建構函式起作用，序號設定為1,2；

但呼叫函式f時，引數型別為numbered型別，又會觸發拷貝建構函式，時每一次都將形參s的序號設定為新值，輸出 3 4 5。

例三：

 1 #include<iostream>
 2 using namespace std;
 3 class numbered{
 4 private:
 5     static int seq;
 6 public:
 7     numbered(){ mysn = seq++;}
 8     numbered(numbered &n) { mysn = seq++;}
 9     int mysn;        
10 }; 
11 int numbered::seq = 0;
12 
13 void f(const numbered &s){
14     cout<<s.mysn<<endl;
15 }
16 int main(int argc,char**argv){
17     numbered a,b=a,c=b;
18     f(a);  f(b);  f(c); 
19     return 0 ; 
20 }

輸出 0 1 2

f的引數被改為const numbered &s,形參型別由類型別轉變為引用型別，傳遞的不是類物件而是類物件的引用，這意味著呼叫f將不會觸發拷貝建構函式將實參拷貝給形參，而是傳遞實參的引用。每次呼叫時，s都是指向實參的引用，序號自然是實參的序號，而不是建立一個新的物件。