2012年4月4日 星期三

[筆記] 變數宣告在什麼位置比較好?

 作者  ie945167 (龍蝦)                                      站內  Lobster
 標題  [筆記] 變數宣告在什麼位置比較好?
 時間  2012/04/04 Wed 17:38:43
───────────────────────────────────────

不負責任聲明:以下憑印象+google寫成,有錯誤很正常 0rz

              如果有人願意指出錯誤,我會很感謝您的 <(_ _)>

--------------------本文開始分隔線--------------------

以前的 C-style 寫法,希望變數都宣告在函式最一開始的地方

這樣的話,有宣告什麼變數都一目了然,非常的方便

如下所示

void main()
{
    int a, b, c

    a = xxx;

    b = xxx;

    c = xxx;
}

而且不論早宣告還是晚宣告,程式在 compile 的時候都一樣會將全部空間都撥出來給你

例如你整個程式宣告了三個 int 的變數

那麼不論這三個變數在最一開始就宣告了

或是在程式中段或尾段才宣告

compile 所撥出來的空間都是一樣的

那麼宣告在什麼時間點或位置有差別嗎?

經主管說明後,真的有差…

最好是在你要使用這個變數前再宣告,而且盡可能的給予初值

如下所示

void main()
{
    …
    …
    …

    int a = XXX;

    int b = XXX;

    int c = XXX;
}

不過我也不清楚給予初值最主要的目的是什麼,在網路上查了一下,
int x = 10;

和
int x;
x = 10;

效果是相同的
但後者彈性太大,而且在 code 海中,x=10 很容易被忽略掉。

另一個說法是:

最好在建構式中,給予所有變數初值,避免執行期間產生錯誤,

因為一般而言,C++在除錯版的時候,會自動給定變數初值(0, NULL),而Release版不會

變數值是看當時配置的記憶體資料內容而定

所以典型的程式描述是我Debug版跑起來都沒錯,但是Release版就是會當機...。

回到正題,這樣做有什麼好處呢?

1. 當你在維護程式時,你想要知道變數影響的地方,

    你只要從宣告的地方開始往下找就好,而不需要從函數最一開始的地方開始看。

2. 若宣告在函數開頭的地方,有時會無法給予初值,

    因為有些變數需要程式先執行某段 code 後才能給予初值。

3. 當程式中途有 return 結束的狀況時,如下所示

    void main()
    {
        int a, b, c

        a = xxx;

        return ???;

        b = xxx;

        c = xxx;
    }

    我印象中是說宣告變數時,背後都會去執行某一段 code

    因此如果一開始就把變數都宣告好,也執行了背後那段 code

    但是程式因為 return 結束或其他原因而沒有使用到這個變數

    那麼執行宣告 b, c 的 code 的時間就浪費掉了

    int 這種資料型態可能還好

    但如果是那種大物件的資料型態,花費的時間有時就會很可觀了

--

     接球會"噴"

我             舉球會"歪"              但是!   我算分超強 o(一︿一+)o

                         攻擊會"OUT"

--
▅◣ Origin:  謠 言 報  bbs.csie.fju.edu.tw
▋◤ Author: ie945167 從 219-85-0-189-adsl-nei3.dynamic.so-net.net.tw 發表

[筆記] const & const_cast

 作者  ie945167 (龍蝦)                                      站內  Lobster
 標題  [筆記] const & const_cast
 時間  2012/04/04 Wed 17:35:48
───────────────────────────────────────

不負責任聲明:以下憑印象+google寫成,有錯誤很正常 0rz

              如果有人願意指出錯誤,我會很感謝您的 <(_ _)>

--------------------本文開始分隔線--------------------

在先前的文章中有提到

指定運算元:A::operator =( const A& a ){}

     盡量加上 const     b:因為有加 const 的關係,可以保證在 function 內,
               ↓       ↓                                      B 值不會被更改
T& operator = const (T& b)
                     ↑
                      &:reference 有加的話效率較高?

當我們希望函數中不要更改任何的物件時

可以使用 const 來限制

如
    void mem_function() const
or
    get_XXX() const



但是有時候我們在函數中不得不去修改某物件的值時該怎麼辦呢?

如
    get_XXX() const
    {
        if(temp > 0)
        {
            temp = ???;
        }

        return temp
    }

我們可以使用 const_cast

來解除 const 不得更改物件狀態或值的限制


可是,這樣就造成矛盾了不是?

原先我們是為了不要修改到函數裡面的物件狀態而限制為 const

但是現在卻又把它給解除了

這樣不是很容易就會出現 bug 嗎?


所以 const_cast 盡可能不要用,或是完全不要用

可以將要修正的值,宣告成

mutable temp

即可

http://caterpillar.onlyfun.net/Gossip/CppGossip/constAndmuttable.html

而且盡可能的使用 const ,可以讓程式更少出錯且易於維護


--
▅◣ Origin:  謠 言 報  bbs.csie.fju.edu.tw
▋◤ Author: ie945167 從 219-85-0-189-adsl-nei3.dynamic.so-net.net.tw 發表
▋※ Modify: 2012/04/04 Wed 17:39:05

[筆記] 複製建構式 copy-constructor

 作者  ie945167 (龍蝦)                                      站內  Lobster
 標題  [筆記] 複製建構式 copy-constructor
 時間  2012/04/04 Wed 17:31:47
───────────────────────────────────────

不負責任聲明:以下憑印象+google寫成,有錯誤很正常 0rz

              如果有人願意指出錯誤,我會很感謝您的 <(_ _)>

--------------------本文開始分隔線--------------------

複製建構式:
A::A(const A &a )
{

}

前一篇文章有提到,C++標準中有幾個函式你不需要寫,C++都會幫你生出來,

而你寫了,就不會幫你產生,複製建構式是其中一個


那什麼時候會需要自己寫一個?

Ans:當有使用指標的時候,不然 copy 的會是 pointer,而不是 data

1. http://www.cnblogs.com/oomusou/archive/2007/01/14/620374.html

當類別資料copy涉及記憶體時,永遠要寫複製建構式與operator =();

複製建構式: A::A(const A &a ){}

指定運算元: A::operator =( const A& a ){}


不然在解構時,同一個運算元會被解構兩次而造成 code 掛掉

2. http://imandrewliao.blogspot.com/2009/01/blog-post_22.html

(第三點的內容)


另外印象中好像有提到在使用 copy-constructor 時

會配合使用 swap function 來做資料的交換

(不過我不知道原因為何…0rz)


如交換 a, b 資料 → a.swap(b)

temp(b)
this → swap(b)
return *this;


另外
    (a = b).function;
與
    a = b;
    a.function

是相同的

--------------------------------------------------

以下是第一個連結的全文轉貼,避免連結失效

(原創) 哪些地方會用到Copy Constructor和Assignment Operator? (C/C++)

C#、Java都沒有copy constructor,所以這對大部分programmer都很陌生

簡單地說,凡需要copy的地方,就需要copy constructor:


1.由copy-initialization方式建立物件。

    Ex.

    Foo foo1;
    Foo foo2(foo1);

    以上直接使用copy constructor。

    string s = "C++ Primer";
    Foo foo = Foo();

    此時是先由default constructor建立一個temporary object後,

    再由copy constructor將temporary object 『copy』給物件。

2.以by value的方式傳進function和由function return值。

    Ex.
    int Foo(int n);

    只要不是使用by reference的方式,就得使用copy constructor。

3.建立STL container中的element。

    Ex.vector<string> svec(5);

    先由string的default constructor建立一個temporary string object,

    再由string的copy constructor『copy』到vector中每個element。

4.由initialization list建立array。

    Ex.int ia[] = {1, 2, 3};

    先由int default contructor先建立temporary int object,

    再由int的copy contructor『copy』到array中。

    所以copy constructor其實是無所不在的,只是我們從來沒有發現,

    雖然C++ compiler會自己synthesize copy constructor,

    但也允許我們自己定義自己的Copy Constructor,這與C#、Java不同。


而assignment operator呢?

Foo foo1;
Foo foo2;
foo2 = foo1;

以上會執行foo2的assignment operator。


所以簡單的說,copy constructor和assignment operator都在做『copy』的動作,

資料是pointer,也就是動態資料時,就必須重新改寫,

否則只會copy pointer,而不是copy data。

--------------------------------------------------

以下是第二個連結的全文轉貼,避免連結失效


建構式與解構式

預設建構式與解構式有許多的地雷,首先,如先前所說,

C++在你沒有撰寫此兩個函式的時候,會自動生成,

那麼因為建構式支援多載,預設解構式還會生成嗎?

答案是不會的,以下以範例說明:

class ClassHasDefaultConstruct
{

};

class ClassHasNoDefaultConstruct
{
    public:
        ClassHasNoDefaultConstruct(int i){}
};


我們可以注意到第二個範例,有寫建構式但不是預設建構式(沒有任何參數的),

此時C++就放棄幫你建立預設建構式了,

可是有時候,我們在使用STL函式庫的時候,強迫要求你設計預設建構式,

所以ClassHasNoDefaultConstruct這個類別是不能為STL容器所用。


這裡有個小伎倆,把有參數的建構式當成預設建構式用,利用預設參數的方式:

class ClassHasNoDefaultConstruct2
{
    public:
        ClassHasNoDefaultConstruct2(int i=0){}
};

使用建構式有一些注意事項,如果你的類別支援繼承,在建構式中,不可呼叫虛擬函式,

因為,物件建構的順序是:基底類別建構式完成後,然後才是衍生類別建構,

所以在基底類別建構式中呼叫虛擬函式,永遠是基底類別的函式



其次養成習慣,最好在建構式中,給予所有變數初值,避免執行期間產生錯誤,

因為一般而言,

C++在除錯版的時候,會自動給定變數初值(0, NULL),

而Release版不會,

變數值是看當時配置的記憶體資料內容而定,

所以典型的程式描述是我Debug版跑起來都沒錯,但是Release版就是會當機...。

class BadSample
{
    private:
        char *ptr;

    public:
        BadSample(){};
        ~BadSample()
{

if( ptr ) delete ptr; // 當機
};

};


第三是當類別資料copy涉及記憶體時,永遠要寫複製建構式與operator =();

或者,類別不允許這兩個函式的執行,

原因很簡單,以下以程式說明之:

class CopyConstructor
{
    private:
        char *ptr;

    public:
        void ANewFunction()
        {
            ptr=new char[1024];

        }

        ~CopyConstructor()
        {
            if( ptr ) delete[] ptr; // 假設建構式有把ptr=NULL;
        }
};


以下例子解構時都會當機,因為ptr會被釋放多次:

CopyConstructor a;
a.ANewFunction();

CopyConstructor b(a); // b物件刪除的時候,ptr釋放一次,等到a物件刪除時,又一次

CopyConstructor c;
c=a;  // 同上


所以要嗎你把類別這麼寫:

class CopyConstructor
{
    private:
        char *ptr;

    public:
        void ANewFunction()
        {
            ptr=new char[1024];
        }

        CopyConstructor(const CopyConstructor& c )
        {   
            ptr=new char[1024]; // 各自配置各自的記憶體
            memcpy( ptr, c.ptr, 1024 );
        }

        void operator =(const CopyConstructor& c ) // 簡化起見,不討論回傳值
        {   
            ptr=new char[1024]; // 各自配置各自的記憶體
            memcpy( ptr, c.ptr, 1024 );
        }

        ~CopyConstructor()
        {
            if( ptr ) delete[] ptr; // 假設建構式有把ptr=NULL;
        }
};


要嗎你把類別這麼寫:

class CopyConstructor
{
    private:
    char *ptr;

    public:
        void ANewFunction()
        {
            ptr=new char[1024];
        }

        CopyConstructor(const CopyConstructor& c )
        {   
            ASSERT(0);  //給他當機
        }

        void operator =(const CopyConstructor& c ) // 簡化起見,不討論回傳值
        {
            ASSERT(0);  //給他當機
        }

        ~CopyConstructor()
        {
            if( ptr ) delete[] ptr; // 假設建構式有把ptr=NULL;
        }
};


解構式的注意事項是,如果想讓後續類別繼承,

一定要用virtual,讓繼承解構的順序正確,

還有,同建構式般,不可以在解構式中,呼叫虛擬函式,

因為解構是繼承物件先解構,然後才基底物件,

衍生物件已經不見了,基底物件去哪呼叫正確的虛擬函式呢?

--

     身高不是距離
                   技巧不是問題
                                 只要有"心"
                                             人人都可 定‧三‧米


--
▅◣ Origin:  謠 言 報  bbs.csie.fju.edu.tw
▋◤ Author: ie945167 從 219-85-0-189-adsl-nei3.dynamic.so-net.net.tw 發表
▋※ Modify: 2012/04/04 Wed 17:39:15

[筆記] 如何宣告初始值?

 作者  ie945167 (龍蝦)                                      站內  Lobster
 標題  [筆記] 如何宣告初始值?
 時間  2012/04/04 Wed 17:09:57
───────────────────────────────────────

不負責任聲明:以下憑印象+google寫成,有錯誤很正常 0rz

              如果有人願意指出錯誤,我會很感謝您的 <(_ _)>

--------------------本文開始分隔線--------------------


一般人在宣告初始值時,大部分都採用下面的方式

T::T()
{
    a = XXX;
    b = XXX;
    c = XXX;
}

也有另一種做法如下

T::T()
: a(120), b(0.3), c(5)
{

}

這兩者有差嗎?以結果來看沒差。
但在執行效率上,後者會較快

因為前者的做法,等於後者做兩次
原因我也沒有辦法說得很清楚
大家可以去看這篇文章
http://imandrewliao.blogspot.com/2009/01/c-1.html
或是去參考 Effective C++ 這本書

重點是,後者在使用上有個限制,就是給初始值的順序要與變數宣告的順序一致
不然給值時會發生錯誤
原因同樣在上述 blog 文章中可以看到

--------------------------------------------------
以下為全文轉貼,避免連結失效

變數初值

程式寫這麼久,以前經常會遇到,"啊? C++不可以這樣嗎?"或者是"這樣寫有差別嗎?"
的驚訝

想說這可能不只是只有我有的感覺,因此把這些東西分享出來,給大家做參考

你也可以參考Effective C++這本書籍:

初值化(Initial)和給定數值(Assign)

(a) 什麼是initial?
    變數宣告的時候,直接給了數值,像是:
    int a=10;

(b) 什麼是Assign?
    變數宣告完後,再另外給定數值,像是:
    int a;
    a=10;

這兩種寫法有差異嗎? 對build-in類型,像是int, float, ...沒有差別

但是對物件而言,就決定了一點點效能上的差別了,我以一個類別A來解釋:

class A
{

}; // 什麼事都沒有的類別


使用assign你必須先宣告一個物件 A a;

此時,物件已經執行了一次建構式,把內部數值初始一次

你也許會問,類別中沒有建構式啊?何來呼叫建構式?

答案是,類別雖然沒有設計建構式

但是C++標準中有幾個函式你不需要寫,C++都會幫你生出來

而你寫了,就不會幫你產生

分別是:
預設建構式: A::A(){}
解構式: A::~A(){}
複製建構式: A::A(const A &a ){}
指定運算元: A::operator =( const A& a ){}

所以當你下A a;a=b;這樣的程式時,已經執行了一次建構式,

之後再一行assign,物件又會執行一次"指定運算元",

所以你跑了兩次物件的函式。

而Initial呢? 看起來A a=b; 這樣的程式碼,

同樣是執行一次建構式,然後再執行一次指定運算元?

答案是,編譯器直接執行複製建構式,所有數值一次搞定

比起Assign快了一倍,也許不多

但是,如果你的物件內部,變數數量超多

一個assign需要執行的指令碼很多,那也許就有點可觀了:)


說到建構式,也許有人會問,他看過以下兩種程式碼,有差別嗎?
A::A()
: a(120), c(0.3)
{
}

A::A()
{
    a=120;
    c=0.3;
}

答案依照結果論而言,沒有差別,但是同樣潛在一點點效能上的差別

首先第一種方法A()後面接著的":a(...." 那行稱為 "member initializer list"

專供給物件內成員變數的初值化,與呼叫基底類別的建構式所用

在這個時候,物件的記憶體還在配置中

C++會一邊配置記憶體,一邊把你指定的數值塞進去

所以,變數給定數值的次數只有一次


而下面那種A::A(){ ... } 的方式呢?

此時記憶體已經配置完成,變數數值已經給定過了一次,而此時又再設定一次

所以跑了兩次數值給定的程序,所以會慢一滴滴。


member initializer list這麼好用,有什麼限制嗎?

有的,指定順序要跟變數宣告的順序一致

原因說過,C++會一邊配置記憶體,一邊給定數值

如果順序不對,以下的程式就可能出錯:

class A
{
    vector buf;
    int size;
    A() : buf(size), size(20)
    ....
};


你希望配置大小為size的vector的陣列,但是在 呼叫buf(size)建構時

size記憶體還沒配置出來,根本不知道size的數值

而,size(20)初值後,buf(size)已經執行過了,所以會發生錯誤

所以正確的順序:

class A
{
    int size;
    vector buf;
    A() : size(20), buf(size)
    ....
};


--
▅◣ Origin:  謠 言 報  bbs.csie.fju.edu.tw
▋◤ Author: ie945167 從 219-85-0-189-adsl-nei3.dynamic.so-net.net.tw 發表

[筆記] 實務分享:當在 free(p) 時,程式出錯,問題何在?

 作者  ie945167 (龍蝦)                                      站內  Lobster
 標題  [筆記] 實務分享:當在 free(p) 時,程式出錯,問題何在?
 時間  2012/04/04 Wed 17:04:25
───────────────────────────────────────

不負責任聲明:以下憑印象+google寫成,有錯誤很正常 0rz

              如果有人願意指出錯誤,我會很感謝您的 <(_ _)>

--------------------本文開始分隔線--------------------

主管分享的經驗,我自己連 malloc, free 都沒寫過…悲劇 0rz

主管:「最近遇到一個問題,有個程式在 free(p)的時候掛掉,請問大家,原因為何?」

malloc():動態配置記憶體
free():釋放記憶體

p = malloc(100); //配置100個 byte 的記憶體位置給p,但不做初始化的動作
…
…
...
free(p); //掛掉 囧 why?

常見可能的原因:
1. p = NULL
2. p指標飛了,分配時的指向不一樣
3. free(p),p的值不是通過malloc()等函數得到的
4. p已經free過了
還有什麼原因?

我印象中,最後好像是 free 的空間大小與原本 malloc 所配置的大小不一樣
至於是怎麼查出來的呢?
可以看下面的解說

下面是一個記憶體空間

memory cookie   memory
 ______________________
|4 ~ 8 byte  | p      |
 ___________

              ↑
            pointer

(圖畫得不好請見諒…)

在指標(pointer)所指的位置前 4~8 個byte,有所謂的 memory cookie

好像是用來記錄後面的 memory 分配的大小

因此可以用 memory cookie 來判斷 free 的空間大小是否與原本配置的大小相同。

(主管用意在於讓我們知道有所謂的 memory cookie 這種東西的存在可以利用)


題外話,google得來:

malloc 和free 一定要成對出現,有malloc 的,一定要有free,

且注意malloc 分配的大小,防止破壞管理分配記憶體的資訊。

當陣列ar作為參數時,在函數體內,ar只是一個指標,

所以 sizeof(array)=4,而非陣列所含元素個數+1.

--

     接球會"噴"

我             舉球會"歪"              但是!   我算分超強 o(一︿一+)o

                         攻擊會"OUT"

--
▅◣ Origin:  謠 言 報  bbs.csie.fju.edu.tw
▋◤ Author: ie945167 從 219-85-0-189-adsl-nei3.dynamic.so-net.net.tw 發表