C++詳細講解對象的構造

2022-04-19 20:48:04 來源:易采站長站 作者:

C++詳細講解對象的構造

目錄
一、對象的構造(上)1.1 對象的初始值1.2 對象的初始化1.3 小結二、對象的構造(中)2.1 構造函數2.2小實例2.3 小結三、對象的構造(下)3.1 特殊的構造函數3.2 拷貝構造函數3.3 小結

一、對象的構造(上)

1.1 對象的初始值

問題:對象中成員變量的初始值是多少?

下面的類定義中成員變量 i 和 j 的初始值為多少?

下面看一段成員變量初始值的代碼:

#include<stdio.h>
 
class Test
{
    private:
        int i;
        int j;
    public:
        int getI() {return i;}
        int getJ() {return j;}
};
 
Test gt;
 
int main()
{
    printf("gt.i = %d\n", gt.getI());
    printf("gt.j = %d\n", gt.getJ());
    
    Test t1;
    
    printf("t1.i = %d\n", t1.getI());
    printf("t1.j = %d\n", t1.getJ());
    
    Test* pt = new Test;
    
    printf("pt->i = %d\n", pt->getI());
    printf("pt->j = %d\n", pt->getJ());   
    
    delete pt;
    
    return 0;
}

下面為輸出結果:

對象t1 所占用的存儲空間在棧上面,而且成員變量 i 和 j 也沒有明確的初始值,所以初始值就不定。對象 gt 所占用的存儲空間在全局數據區,所以初始值統一為 0。

Test* pt = new Test;意味著在堆空間中生成一個 Test 對象,雖然 pt->i 和 pt->j 均為 0,這只是巧合罷了,因為在堆上創建對象時,成員變量初始為隨機值。

注:類得到的其實是數據類型,所以說通過這種數據類型在全局數據區、棧和堆上面都能夠生成對象。

1.2 對象的初始化

從程序設計的角度,對象只是變量,因此:

在棧上創建對象時,成員變量初始為隨機值在堆上創建對象時,成員變量初始為隨機值在靜態存儲區創建對象時,成員變量初始為 0 值

生活中的對象都是在初始化后上市的

初始狀態(出廠設置)是對象普遍存在的一個狀態

—股而言,對象都需要—個確定的初始狀態

解決方案

在類中提供一個 public 的 initialize 函數對象創建后立即調用 initialize 函數進行初始化

如下:

下面看一段初始化函數的代碼:

#include<stdio.h>
 
class Test
{
    private:
        int i;
        int j;
    public:
        int getI() {return i;}
        int getJ() {return j;}
        void initialize()
        {
            i = 1;
            j = 2;
        }
};
 
Test gt;
 
int main()
{
    gt.initialize();
    
    printf("gt.i = %d\n", gt.getI());
    printf("gt.j = %d\n", gt.getJ());
    
    Test t1;
    
    t1.initialize();
    
    printf("t1.i = %d\n", t1.getI());
    printf("t1.j = %d\n", t1.getJ());
    
    Test* pt = new Test;
    
    pt->initialize();
    
    printf("pt->i = %d\n", pt->getI());
    printf("pt->j = %d\n", pt->getJ());   
    
    delete pt;
    
    return 0;
}

下面為輸出結果:

存在的問題

initialize 只是一個普通函數,必須顯示調用如果未調用 initialize 函數,運行結果是不確定的

下面為解決辦法:

C++中可以定義與類名相同的特殊成員函數

這種特殊的成員函數叫做構造函數

構造沒有任何返回類型的聲明構造函數在對象定義時自動被調用

下面來體驗一下構造函數:

#include<stdio.h>
 
class Test
{
    private:
        int i;
        int j;
    public:
        int getI() {return i;}
        int getJ() {return j;}
        Test()
        {
            printf("Test() Begin\n");
        
            i = 1;
            j = 2;
        
            printf("Test() End\n");
        }
};
 
Test gt;
 
int main()
{
    printf("gt.i = %d\n", gt.getI());
    printf("gt.j = %d\n", gt.getJ());
    
    Test t1;
    
    printf("t1.i = %d\n", t1.getI());
    printf("t1.j = %d\n", t1.getJ());
    
    Test* pt = new Test;
    
    printf("pt->i = %d\n", pt->getI());
    printf("pt->j = %d\n", pt->getJ());   
    
    delete pt;
    
    return 0;
}

下面為輸出結果:

可以看到,Test() Begin 和 Test() End 出現了三次,也就是說,Test() 這個構造函數被調用了三次,這是因為創建了三個對象。

1.3 小結

每個對象在使用之前都應該初始化類的構造函數用于對象的初始化構造函數與類同名并且沒有返回值構造函數在對象定義時自動被調用

二、對象的構造(中)

2.1 構造函數

帶有參數的構造函數

構造函數可以根據需要定義參數一個類中可以存在多個重載的構造函數構造函數的重載遵循 C++ 重載的規則

如下:

友情提醒

對象定義和對象聲明不同

對象定義--申請對象的空間并調用構造函數對象聲明--告訴編譯器存在這樣一個對象

如下:

構造函數的自動調用

如下:

下面看一段帶參數的構造函數的代碼:

#include <stdio.h>
 
class Test
{
    public:
        Test() 
        { 
            printf("Test()\n");
        }
        Test(int v) 
        { 
            printf("Test(int v), v = %d\n", v);
        }
};
 
int main()
{
    Test t;      // 調用 Test()
    Test t1(1);  // 調用 Test(int v)
    Test t2 = 2; // 調用 Test(int v)
    
    return 0;
}

下面為輸出結果,和預想中的一致。

這里需要明確一個問題,int i = 1;與 int i; i = 1;的不同。前者是初始化,后者是先定義,再賦值。后者由于定義 i 時沒有初始化,所以 i 的值時隨機的。C語言中這兩者差別很小,但是在 C++ 中兩者差異很大。差別在于在 C++ 中初始化會調用構造函數。下面看一個例子,在上述代碼的基礎上加一行代碼 t = t2;

#include <stdio.h>
 
class Test
{
    public:
        Test() 
        { 
            printf("Test()\n");
        }
        Test(int v) 
        { 
            printf("Test(int v), v = %d\n", v);
        }
};
 
int main()
{
    Test t;      // 調用 Test()
    Test t1(1);  // 調用 Test(int v)
    Test t2 = 2; // 調用 Test(int v)
    
    t = t2;
    
    return 0;
}

下面為輸出結果,可以看到與上面的代碼輸出結果一模一樣。這就因為 C++ 中初始化和賦值不同,初始化會調用構造函數,賦值的時候則不用。

下面再看一個例子:

#include <stdio.h>
 
class Test
{
    public:
        Test() 
        { 
            printf("Test()\n");
        }
        Test(int v) 
        { 
            printf("Test(int v), v = %d\n", v);
        }
};
 
int main()
{
    Test t;      // 調用 Test()
    Test t1(1);  // 調用 Test(int v)
    Test t2 = 2; // 調用 Test(int v)
    
    int i(100);
    
    printf("i = %d\n", i);
    
    return 0;
}

下面為輸出結果:

構造函數的調用

一般情況下,構造函數在對象定義時被自動調用—些特殊情況下,需要手工調用構造函數

下面看一段構造函數手動調用的代碼:

#include <stdio.h>
 
class Test
{
    private:
        int m_value;
    public:
        Test() 
        { 
            printf("Test()\n");
        
            m_value = 0;
        }
        
        Test(int v) 
        { 
            printf("Test(int v), v = %d\n", v);
        
            m_value = v;
        }
        
        int getValue()
        {
            return m_value;
        }
};
 
int main()
{
    Test ta[3] = {Test(), Test(1), Test(2)};      
    
    for (int i = 0; i < 3; i++)
    {
        printf("ta[%d].getValue() = %d\n", i, ta[i].getValue());
    }
    
    Test t = Test(100);
    
    printf("t.getValue() = %d\n", t.getValue());
    
    return 0;
}

下面為輸出結果,可以看到,Test(1)、Test(2) 和 Test(100) 均為手動調用構造函數。

2.2小實例

需求:開發一個數組類解決原生數組的安全性問題

提供函數獲取數組長度提供函數獲取數組元素提供函數設置數組元素

IntArray.h:

#ifndef _INTARRAY_H_
 
#define _INTARRAY_H_

class IntArray
 
{
    private:
        int m_length;
 
        int* m_pointer;
    public:
        IntArray(int len);
 
        int length();
 
        bool get(int index, int& value);
 
        bool set(int index ,int value);
 
        void free();
};
#endif

IntArray.cpp:

#include "IntArray.h"
 
 
 
IntArray::IntArray(int len)
 
{
 
    m_pointer = new int[len];
 
    
 
    for (int i = 0; i < len; i++)
 
    {
 
        m_pointer[i] = 0;
 
    }
 
    
 
    m_length = len;
 
}
 
 
 
int IntArray::length()
 
{
 
    return m_length;
 
}
 
 
 
bool IntArray::get(int index, int& value)
 
{
 
    bool ret = (0 <= index) && (index < length());
 
    
 
    if( ret )
 
    {
 
        value = m_pointer[index];
 
    }
 
    
 
    return ret;
 
}
 
 
 
bool IntArray::set(int index, int value)
 
{
 
    bool ret = (0 <= index) && (index < length());
 
    
 
    if( ret )
 
    {
 
        m_pointer[index] = value;
 
    }
 
    
 
    return ret;
 
}
 
 
 
void IntArray::free()
 
{
 
    delete[]m_pointer;
 
}

main.cpp:

#include <stdio.h>
 
#include "IntArray.h"
 
 
 
int main()
 
{
 
    IntArray a(5);    
 
    
 
    for (int i = 0; i < a.length(); i++)
 
    {
 
        a.set(i, i + 1);
 
    }
 
    
 
    for (int i = 0; i < a .length(); i++)
 
    {
 
        int value = 0;
 
        
 
        if( a.get(i, value) )
 
        {
 
            printf("a[%d] = %d\n", i, value);
 
        }
 
    }
 
    
 
    a.free();
 
    
 
    return 0;
 
}

下面為輸出結果:

這樣寫出來的數組很安全,沒有數組越界問題。

2.3 小結

構造函數可以根據需要定義參數構造函數之間可以存在重載關系構造函數遵循 C++ 中重載函數的規則對象定義時會觸發構造函數的調用在一些情況下可以手動調用構造函數

三、對象的構造(下)

3.1 特殊的構造函數

兩個特殊的構造函數

無參構造函數

沒有參數的構造函數當類中沒有定義構造函數時,編譯器默認提供一個無參構造函數,并且其函數體為空

拷貝構造函數

參數為 const class_name& 的構造函數當類中沒有定義拷貝構造函數時,編譯器默認提供一個拷貝構造函數,簡單的進行成員變量的值復制

下面看一段無參數構造函數的代碼(代碼3-1):

#include <stdio.h>
 
class Test
{
    private:
        int i;
        int j;
    public:
        int getI()
        {
            return i;
        }
        int getJ()
        {
            return j;
        }
};
 
int main()
{
    Test t;
    
    return 0;
}

可以看到,編譯通過:

創建一個類的對象必須要調用構造函數,為什么能夠編譯通過呢?這是因為編譯器在發現我們沒有定義構造函數時,會默認提供一個無參構造函數,等效如(代碼3-2):

#include <stdio.h>
 
class Test
{
    private:
        int i;
        int j;
    public:
        int getI()
        {
            return i;
        }
        int getJ()
        {
            return j;
        }
        Test()
        {
        }
};
 
int main()
{
    Test t;
    
    return 0;
}

小貼士:所以說,class T { }; 里面不是什么都沒有,里面至少有一個無參構造函數。

下面再來看一段代碼(代碼3-3):

#include <stdio.h>
 
class Test
{
    private:
        int i;
        int j;
    public:
        int getI()
        {
            return i;
        }
        int getJ()
        {
            return j;
        }
};
 
int main()
{
    Test t1;
    Test t2 = t1;
    
    printf("t1.i = %d, t1.j = %d\n", t1.getI(), t1.getJ());
    printf("t2.i = %d, t2.j = %d\n", t2.getI(), t2.getJ());
    
    return 0;
}

下面為輸出結果:

這里的 i 和 j 打印出來的都是隨機值,這是因為類里面沒有手工編寫的構造函數,所以 t1 和 t2 所采用的就是編譯器提供的默認無參構造函數構造的,編譯器提供的無參構造函數為空,所以 i 和 j 的值就是隨機的。

上述代碼就相當于(代碼3-4):

#include <stdio.h>
 
class Test
{
    private:
        int i;
        int j;
    public:
        int getI()
        {
            return i;
        }
        int getJ()
        {
            return j;
        }
        Test(const Test& t)
        {
            i = t.i;
            j = t.j;        
        }
};
 
int main()
{
    Test t1;
    Test t2 = t1;
    
    printf("t1.i = %d, t1.j = %d\n", t1.getI(), t1.getJ());
    printf("t2.i = %d, t2.j = %d\n", t2.getI(), t2.getJ());
    
    return 0;
}

但是編譯的時候會報錯:

這是因為在類里面沒有編寫任何構造函數時,編譯器才提供默認的無參構造函數。這里手工編寫了一個拷貝構造函數,編譯器就不會提供默認的無參構造函數,需要自己把無參構造函數加上。

如下,自己加上無參構造函數(代碼3-5):

#include <stdio.h>
class Test
{
    private:
        int i;
        int j;
    public:
        int getI()
        {
            return i;
        }
        int getJ()
        {
            return j;
        }
        Test(const Test& t)
        {
            i = t.i;
            j = t.j;        
        }
        Test()
        {
        }
};
 
int main()
{
    Test t1;
    Test t2 = t1;
    
    printf("t1.i = %d, t1.j = %d\n", t1.getI(), t1.getJ());
    printf("t2.i = %d, t2.j = %d\n", t2.getI(), t2.getJ());
    
    return 0;
}

這樣就能編譯通過了,而且效果跟代碼3-3的相同:

3.2 拷貝構造函數

拷貝構造函數的意義

兼容C語言的初始化方式

初始化行為能夠符合預期的邏輯

淺拷貝

拷貝后對象的物理狀態相同(物理狀態指的是對象占據的內存當中每個字節是否相等,如代碼3-6)

深拷貝

拷貝后對象的邏輯狀態相同(邏輯狀態指的是指針所指向的內存空間的值是否相同,如代碼3-9)

注:編譯器提供的拷貝構造函數只進行淺拷貝!

下面看一段代碼(代碼3-6):

#include <stdio.h>
 
class Test
{
    private:
        int i;
        int j;
        int* p;
    public:
        int getI()
        {
            return i;
        }
        int getJ()
        {
            return j;
        }
        int* getP()
        {
            return p;
        }
        Test(int v)
        {
            i = 1;
            j = 2;
            p = new int;
        
            *p = v;
        }
 
};
 
int main()
{
    Test t1(3);
    Test t2 = t1;
    
    printf("t1.i = %d, t1.j = %d, t1.p = %p\n", t1.getI(), t1.getJ(), t1.getP());
    printf("t2.i = %d, t2.j = %d, t2.p = %p\n", t2.getI(), t2.getJ(), t2.getP());
    
    return 0;
}

下面為輸出結果:

這段程序的第一個問題就是 t1 和 t2 的 p 指針都指向同一個堆空間中的地址,第二個問題就是申請了內存并沒有釋放,會造成內存泄漏。

下面加上釋放內存的代碼(代碼3-7):

#include <stdio.h>
 
class Test
{
    private:
        int i;
        int j;
        int* p;
    public:
        int getI()
        {
            return i;
        }
        int getJ()
        {
            return j;
        }
        int* getP()
        {
            return p;
        }
        Test(int v)
        {
            i = 1;
            j = 2;
            p = new int;
        
            *p = v;
        }
        void free()
        {
            delete p;
        }
 
};
 
int main()
{
    Test t1(3);
    Test t2 = t1;
    
    printf("t1.i = %d, t1.j = %d, t1.p = %p\n", t1.getI(), t1.getJ(), t1.getP());
    printf("t2.i = %d, t2.j = %d, t2.p = %p\n", t2.getI(), t2.getJ(), t2.getP());
    
    t1.free();
    t2.free();
    
    return 0;
}

下面為輸出結果,編譯能通過,但是運行時發生了錯誤,釋放了兩次堆空間的內存:

下面為解決方法(代碼3-8):

#include <stdio.h>
 
class Test
{
    private:
        int i;
        int j;
        int* p;
    public:
        int getI()
        {
            return i;
        }
        
        int getJ()
        {
            return j;
        }
        
        int* getP()
        {
            return p;
        }
        
        Test(const Test& t)
        {
            i = t.i;
            j = t.j;
            p = new int;
            
            *p = *t.p;
        }
        
        Test(int v)
        {
            i = 1;
            j = 2;
            p = new int;
        
            *p = v;
        }
        
        void free()
        {
            delete p;
        }
 
};
 
int main()
{
    Test t1(3);
    Test t2(t1);
    
    printf("t1.i = %d, t1.j = %d, t1.p = %p\n", t1.getI(), t1.getJ(), t1.getP());
    printf("t2.i = %d, t2.j = %d, t2.p = %p\n", t2.getI(), t2.getJ(), t2.getP());
    
    t1.free();
    t2.free();
    
    return 0;
}

下面為輸出結果,可以到 t1 和 t2 的 p 指針分別指向不同的堆空間地址:

如果我們看一下邏輯狀態,也就是 *t1.p 和 *t2.p 的值,代碼如下(代碼3-9):

#include <stdio.h>
 
class Test
{
    private:
        int i;
        int j;
        int* p;
    public:
        int getI()
        {
            return i;
        }
        
        int getJ()
        {
            return j;
        }
        
        int* getP()
        {
            return p;
        }
        
        Test(const Test& t)
        {
            i = t.i;
            j = t.j;
            p = new int;
            
            *p = *t.p;
        }
        
        Test(int v)
        {
            i = 1;
            j = 2;
            p = new int;
        
            *p = v;
        }
        
        void free()
        {
            delete p;
        }
 
};
 
int main()
{
    Test t1(3);
    Test t2(t1);
    
    printf("t1.i = %d, t1.j = %d, t1.p = %p\n", t1.getI(), t1.getJ(), t1.getP());
    printf("t2.i = %d, t2.j = %d, t2.p = %p\n", t2.getI(), t2.getJ(), t2.getP());
    
    t1.free();
    t2.free();
    
    return 0;
}

下面為輸出結果,可以看到 *t1.p 和 *t2.p 的值相同,也就是說邏輯狀態相同,這就叫做深拷貝。

什么時候需要進行深拷貝?

對象中有成員指代了系統中的資源

成員指向了動態內存空間成員打開了外存中的文件成員使用了系統中的網絡端口......

問題分析

下面就是淺拷貝:

一般性原則

自定義拷貝構造函數,必然需要實現深拷貝?。?!

下面看一個使用深拷貝,對前面數組的代碼進行改造。

IntArray.h:

#ifndef _INTARRAY_H_
 
#define _INTARRAY_H_
class IntArray
 
{
 
    private:
 
        int m_length;
 
        int* m_pointer;
 
    public:
 
        IntArray(int len);
 
        IntArray(const IntArray& obj);
 
        int length();
 
        bool get(int index, int& value);
 
        bool set(int index ,int value);
 
        void free();
 
};
#endif

IntArray.cpp:

#include "IntArray.h"
 
 
 
IntArray::IntArray(int len)
 
{
 
    m_pointer = new int[len];
 
    
 
    for (int i = 0; i < len; i++)
 
    {
 
        m_pointer[i] = 0;
 
    }
 
    
 
    m_length = len;
 
}
 
 
 
IntArray::IntArray(const IntArray& obj)
 
{
 
    m_length = obj.m_length;
 
    
 
    m_pointer = new int[obj.m_length];
 
    
 
    for (int i = 0; i < obj.m_length; i++)
 
    {
 
        m_pointer[i] = obj.m_pointer[i];
 
    }
 
}
 
 
 
int IntArray::length()
 
{
 
    return m_length;
 
}
 
 
 
bool IntArray::get(int index, int& value)
 
{
 
    bool ret = (0 <= index) && (index < length());
 
    
 
    if( ret )
 
    {
 
        value = m_pointer[index];
 
    }
 
    
 
    return ret;
 
}
 
 
 
bool IntArray::set(int index, int value)
 
{
 
    bool ret = (0 <= index) && (index < length());
 
    
 
    if( ret )
 
    {
 
        m_pointer[index] = value;
 
    }
 
    
 
    return ret;
 
}
 
 
 
void IntArray::free()
 
{
 
    delete[]m_pointer;
 
}

main.cpp:

#include <stdio.h>
 
#include "IntArray.h"
 
 
 
int main()
 
{
 
    IntArray a(5);    
 
    
 
    for (int i = 0; i < a.length(); i++)
 
    {
 
        a.set(i, i + 1);
 
    }
 
    
 
    for (int i = 0; i < a.length(); i++)
 
    {
 
        int value = 0;
 
        
 
        if( a.get(i, value) )
 
        {
 
            printf("a[%d] = %d\n", i, value);
 
        }
 
    }
 
    
 
    IntArray b = a;
 
    
 
    for (int i = 0; i < b.length(); i++)
 
    {
 
        int value = 0;
 
        
 
        if( b.get(i, value) )
 
        {
 
            printf("b[%d] = %d\n", i, value);
 
        }
 
    }
 
    
 
    a.free();
 
    b.free();
 
    
 
    return 0;
 
}

下面為輸出結果:

可以看到 b 數組里面的元素與 a 數組里面的元素相同,這就是深拷貝構造函數的結果。

3.3 小結

C++ 編譯器會默認提供構造函數

無參構造函數用于定義對象的默認初始狀態

拷貝構造函數在創建對象時拷貝對象的狀態

對象的拷貝有淺拷貝和深拷貝兩種方式

淺拷貝使得對象的物理狀態相同深拷貝使得對象的邏輯狀態相同

到此這篇關于C++詳細講解對象的構造的文章就介紹到這了,更多相關C++ 對象的構造內容請搜索易采站長站以前的文章或繼續瀏覽下面的相關文章希望大家以后多多支持易采站長站!

如有侵權,請聯系QQ:279390809 電話:15144810328

相關文章

色七七影院_香港三级台湾三级在线播放_男人放进女人阳道猛进猛出