跟java沒區別 都是同樣的方法名,不同的參數。

#include <iostream>
using namespace std;
class A{
public:
　　void set(int =30,int=5);
　　void count(bool=false);
private:
　　int w;
　　int h;
};
void A::set(int width,int height){
　　w=width;
　　h=height;
}
void A::count(bool val){
　　if(val==true){
　　　　cout<<"val的值為真時:"<<w*h<<endl;
　　}else{
　　　　cout<<"val的值為假時:"<<w*h/2<<endl;
　　}
}
int main(){
　　A a;
　　a.set();
　　a.count();
}
c++中可以寫這種缺省的函數,java中應該是不可以,我個人沒寫過,也沒有見別人寫過,時間有限就不寫demo測試了,有興趣的可以試下。
不過似乎c++中這種默認的方法必須 不是內聯函數才行,也就是聲明跟方法分開寫。

c++中有一種特殊類的成員變量初始化的寫法
例:
class rectangle{
public:
　　rectangle():length(3),width(5){}
private:
　　const int length;
　　const int width;
}
在構造函數的右邊有個冒號 (:),然后是成員變量的名稱和一對小括號(),小括號中是要初始化的值或者表達式,如果對多個成員進行初始化,那么就要用逗號將它們隔開,最后是一對大
括號{},大括號中就是函數所要執行的功能。
這種方式是對成員變量的初始化,而 rectangle(){length=3;}這種方式是對成員進行賦值,當成員有const修飾符 是常量時，賦值的方式就會報錯。
對于像常量和引用只能被初始化,不能被賦值.我們最好在構造函數的函數頭中對常量和引用進行初始化。

class A{
public :
　　A(){}
　　A(A&one){n=one.n;m=one.m;}//這是復制構造函數,系統默認就有的,我們可以復寫也可以不管,在引用一節有關于這個的測試。
　　A(int i,int j){n=i;m=j;}
　　void print(){
　　　　cout<<n<<m;
　　}
private:
　　int n;
　　int m;
}
int main(){
　　A a(2,4);
　　a.print();
　　cout<<"\n";
　　A b(a);
　　return 0;
}

在c++中創建實力對象，是通過指針來引向內存空間的。
A *a;
a=new A;
a->set(3,4);
而java中 是 A a=new A();

class A{
public:
　　explicit A(int x){i=x;cout<<"構造函數執行!"<<i<<endl;}
　　~A(){cout<<"析構函數執行！"<<i<<endl;}
　　void get(){cout<<i<<endl;}
private:
　　int i;
};
int main(){
　　A a(99);
　　a.get();
　　a=1000; //對于c++來說 這句話相當于 a=A(1000);會自動調用默認構造函數,當加上explicit關鍵字時,就不會進行隱式轉換了。
　　return;
}

編譯器提供了默認構造函數和析構函數,同樣也提供了復制構造函數,編譯器提供的默認復制構造函數只是把傳遞進來的對象的每個成員變量復制到新對象的成員變量中去,然后兩個對象中
的變量均指向存放類成員變量的那塊內存區域.加入該變量不是指針變量一般不會立即出錯,加入該變量是指針變量,如圖:(圖片插入總失敗 我就簡單的表示下吧)

　　對象a　　　　　　　　　　　　-->堆<--　　　　　　復制的對象b
　　指針變量x　　　　　　　　　　　　6　　　　　　　　指針成員變量x

現在對象a 有一個指針成員變量x，它指向堆中存放6的那塊內存區域,我們將對象a復制到對象b，如: A b=(a); 由于要復制對象,因此自動調用默認復制構造函數,調用的過程為為:
首先將對象a作為參數傳遞到默認復制構造函數中,然后將對象a的指針成員變量x復制到對象b中,這樣兩個對象的指針x現在都指向同一內存區域。
這樣當這兩個對象中的任何一個超出作用域時,都會出現致命的錯誤。比如說我們將對象a刪除,那么析構函數會自動釋放堆中存放6的那塊內存空間,而對象b的指針變量x扔指向該空間,
由于該空間已經不在,那么對象b的指針變量x現在就變成了一個迷途指針,該程序面臨崩潰的邊緣。
為了解決淺層復制導致的迷途指針問題,我們必須創建自己的復制構造函數,并且在函數里為我們的成員變量分配內存,這樣,在分配完內存后,舊對象的成員變量就可以復制到新的內存區域
中,兩個對象的成員變量都各自擁有自己的內存區域,一個對象在析構后不再會影響到另一個,我們把這種復制方式叫做深層復制。例：
class A{
public:
　　A(){x=new int;*x=5;}
　　~A(){delete x;x=NULL;}
　　//定義一個深層的復制構造函數
　　A(const A&a){//因為在這個函數體中不會修改別名a所引用的原始對象的值.所以將別名a定義為別名常量。這樣加入我們試圖修改傳遞進來的對象,程序就會報錯。
　　　　cout<<"復制構造函數執行...\n"<<endl;
　　　　x=new int;//用復制構造函數創建的新對象的指針成員x來指向它。這樣兩個對象的x指針都指向了不同的內存空間。
　　　　*x=*(a.x);//先通過對象a調用x指針成員后,再通過"*"讀取x指針指向的空間處的值。
　　}
　　void print()const{cout<<*x<<endl;}
　　void set(int i){*x=i;}
private:
　　int *x;
}