2. 程式人生 > >C++解析(20)：智慧指標與型別轉換函式

C++解析(20)：智慧指標與型別轉換函式

阿新 • • 發佈：2018-12-08

0.目錄

1.智慧指標

2.轉換建構函式

3.型別轉換函式

4.小結

1.智慧指標

記憶體洩漏（臭名昭著的Bug）：

  • 動態申請堆空間，用完後不歸還
  • C++語言中沒有垃圾回收機制
  • 指標無法控制所指堆空間的生命週期

我們需要什麼：

  • 需要一個特殊的指標
  • 指標生命週期結束時主動釋放堆空間
  • 一片堆空間最多隻能由一個指標標識
  • 杜絕指標運算和指標比較

解決方案：

  • 過載指標特徵操作符（ -> 和 * ）
  • 只能通過類的成員函式過載
  • 過載函式不能使用引數
  • 只能定義一個過載函式

示例——實現智慧指標：

#include <iostream>
#include <string>

using namespace std;

class Test
{
    int i;
public:
    Test(int i)
    {
        cout << "Test(int i)" << endl;
        this->i = i;
    }
    int value()
    {
        return i;
    }
    ~Test()
    {
        cout << "~Test()" << endl;
    }
};

class Pointer
{
    Test* mp;
public:
    Pointer(Test* p = NULL)
    {
        mp = p;
    }
    Pointer(const Pointer& obj)
    {
        mp = obj.mp;
        const_cast<Pointer&>(obj).mp = NULL;
    }
    Pointer& operator = (const Pointer& obj)
    {
        if( this != &obj )
        {
            delete mp;
            mp = obj.mp;
            const_cast<Pointer&>(obj).mp = NULL;
        }
        
        return *this;
    }
    Test* operator -> ()
    {
        return mp;
    }
    Test& operator * ()
    {
        return *mp;
    }
    bool isNull()
    {
        return (mp == NULL);
    }
    ~Pointer()
    {
        delete mp;
    }
};

int main()
{
    Pointer p1 = new Test(3);
    
    cout << p1->value() << endl;
    
    Pointer p2 = p1;
    
    cout << p1.isNull() << endl;
    
    cout << p2->value() << endl;
    
    return 0;
}

執行結果為：

[[email protected] Desktop]# g++ test.cpp
[[email protected] Desktop]# ./a.out 
Test(int i)
3
1
3
~Test()

智慧指標的使用軍規——只能用來指向堆空間中的物件或者變數

2.轉換建構函式

再論型別轉換：
C語言標準資料型別之間會進行隱式的型別安全轉換
C語言轉換規則如下：

（C語言編譯器支援從小型別（佔用記憶體少）轉換到大型別（佔用記憶體多）的隱式型別轉換，因為這樣的轉換是安全的，不會發生資料截斷或者資料丟失。）

示例——隱式型別轉換的bug：

#include <iostream>
#include <string>

using namespace std;

int main()
{   
    short s = 'a';
    unsigned int ui = 1000;
    int i = -2000;
    double d = i;
    
    cout << "d = " << d << endl;
    cout << "ui = " << ui << endl;
    cout << "ui + i = " << ui + i << endl;
    
    if( (ui + i) > 0 )
    {
        cout << "Positive" << endl;
    }
    else
    {
        cout << "Negative" << endl;
    }
    
    cout << "sizeof(s + 'b') = " << sizeof(s + 'b') << endl;
    
    return 0;
}

執行結果為：

[[email protected] Desktop]# g++ test.cpp
[[email protected] Desktop]# ./a.out 
d = -2000
ui = 1000
ui + i = 4294966296
Positive
sizeof(s + 'b') = 4

（在大多數編譯器看來，int型別，也就是4個位元組的整型數的運算是最高效的。而在sizeof(s + 'b')中，是做加法運算，左運算元和右運算元都可以安全的轉換為int，那麼可以採用更高效的方式來進行運算。於是就出現bug了！）

問題：
普通型別與類型別之間能否進行型別轉換

？
類型別之間能否進行型別轉換？

再論建構函式：

  • 建構函式可以定義不同型別的引數
  • 引數滿足下列條件時稱為轉換建構函式
    1. 有且僅有一個引數
    2. 引數是基本型別
    3. 引數是其它類型別

舊式的C方式強制型別轉換：

編譯器會盡力嘗試讓原始碼通過編譯（普通型別->類型別）：

示例——編譯器自作聰明的行為：

#include <iostream>
#include <string>

using namespace std;

class Test
{
    int mValue;
public:
    Test() { mValue = 0; }
    
    Test(int i) { mValue = i; }
    
    Test operator + (const Test& p)
    {
        Test ret(mValue + p.mValue);
        
        return ret;
    }
    
    int value() { return mValue; }
};

int main()
{   
    Test t;
    t = 5;    // t = Test(5);
    
    Test r;
    r = t + 10;   // r = t + Test(10);
    
    cout << r.value() << endl;
    
    return 0;
}

執行結果為：

[[email protected] Desktop]# g++ test.cpp
[[email protected] Desktop]# ./a.out 
15

編譯器盡力嘗試的結果是隱式型別轉換。

隱式型別轉換：

  • 會讓程式以意想不到的方式進行工作
  • 是工程中bug的重要來源

工程中通過explicit關鍵字杜絕編譯器的轉換嘗試
轉換建構函式被explicit修飾時只能進行顯示轉換
轉換方式：

示例——杜絕編譯器的轉換嘗試：

#include <iostream>
#include <string>

using namespace std;

class Test
{
    int mValue;
public:
    Test() { mValue = 0; }
    
    explicit Test(int i) { mValue = i; }
    
    Test operator + (const Test& p)
    {
        Test ret(mValue + p.mValue);
        
        return ret;
    }
    
    int value() { return mValue; }
};

int main()
{   
    Test t;
    t = static_cast<Test>(5);    // t = Test(5);
    
    Test r;
    r = t + static_cast<Test>(10);   // r = t + Test(10);
    
    cout << r.value() << endl;
    
    return 0;
}

執行結果為：

[[email protected] Desktop]# g++ test.cpp
[[email protected] Desktop]# ./a.out 
15

3.型別轉換函式

問題：
類型別是否能夠型別轉換到普通型別？

型別轉換函式：

  • C++類中可以定義型別轉換函式
  • 型別轉換函式用於將類物件轉換為其它型別
  • 語法規則：

示例——只有想不到，沒有做不到：

#include <iostream>

using namespace std;

class Test
{
    int mValue;
public:
    Test(int i = 0) { mValue = i; }
    operator int() { return mValue; }
};

int main()
{
    Test t(100);
    int i = t; // ==> t.operator int()
    
    cout << "i = " << i << endl;
    
    return 0;
}

執行結果為：

[[email protected] Desktop]# g++ test.cpp
[[email protected] Desktop]# ./a.out 
i = 100

型別轉換函式：

  • 與轉換建構函式具有同等的地位
  • 使得編譯器有能力將物件轉化為其它型別
  • 編譯器能夠隱式的使用型別轉換函式

編譯器會盡力嘗試讓原始碼通過編譯：

型別轉換函式 vs 轉換建構函式：

  • 無法抑制隱式的型別轉換函式呼叫
  • 型別轉換函式可能與轉換建構函式衝突
  • 工程中以Type toType()的公有成員代替型別轉換函式

示例——能通過編譯的型別轉換函式：

#include <iostream>
#include <string>

using namespace std;

class Test;

class Value
{
public:
    Value() {}
};

class Test
{
    int mValue;
public:
    Test(int i = 0) { mValue = i; }
    int value() { return mValue; }
    operator Value()
    {
        Value ret;
        cout << "operator Value()" << endl;
        return ret;
    }
};

int main()
{   
    Test t(100);
    Value v = t; // ==> t.operator Value()
    
    return 0;
}

示例——能通過編譯的轉換建構函式：

#include <iostream>
#include <string>

using namespace std;

class Test;

class Value
{
public:
    Value() {}
    Value(Test& t) {}
};

class Test
{
    int mValue;
public:
    Test(int i = 0) { mValue = i; }
    int value() { return mValue; }
};

int main()
{   
    Test t(100);
    Value v = t; // ==> Value(t)
    
    return 0;
}

示例——衝突的型別轉換函式與轉換建構函式：

#include <iostream>
#include <string>

using namespace std;

class Test;

class Value
{
public:
    Value() {}
    Value(Test& t) {}
};

class Test
{
    int mValue;
public:
    Test(int i = 0) { mValue = i; }
    int value() { return mValue; }
    operator Value()
    {
        Value ret;
        cout << "operator Value()" << endl;
        return ret;
    }
};

int main()
{   
    Test t(100);
    Value v = t;
    
    return 0;
}

報錯資訊為：

[[email protected] Desktop]# g++ test.cpp
test.cpp: In function ‘int main()’:
test.cpp:32: error: conversion from ‘Test’ to ‘Value’ is ambiguous
test.cpp:21: note: candidates are: Test::operator Value()
test.cpp:12: note:                 Value::Value(Test&)

示例——使用explicit關鍵字避免衝突：

#include <iostream>
#include <string>

using namespace std;

class Test;

class Value
{
public:
    Value() {}
    explicit Value(Test& t) {}
};

class Test
{
    int mValue;
public:
    Test(int i = 0) { mValue = i; }
    int value() { return mValue; }
    operator Value()
    {
        Value ret;
        cout << "operator Value()" << endl;
        return ret;
    }
};

int main()
{   
    Test t(100);
    Value v = t;
    
    return 0;
}

4.小結

  • 指標特徵操作符（ -> 和 * ）可以被過載
  • 過載指標特徵符能夠使用物件代替指標
  • 智慧指標只能用於指向堆空間中的記憶體
  • 智慧指標的意義在於最大程度的避免記憶體問題
  • 轉換建構函式只有一個引數
  • 轉換建構函式的引數型別是其它型別
  • 轉換建構函式在型別轉換時被呼叫
  • 隱式型別轉換是I程中bug的重要來源
  • explicit關鍵字用於杜絕隱式型別轉換
  • C++類中可以定義型別轉換函式
  • 型別轉換函式用於將類物件轉換為其它型別
  • 型別轉換函式與轉換建構函式具有同等的地位
  • 工程中以Type toType()的公有成員代替型別轉換函式

相關推薦

C++解析(20)：智慧指標與型別轉換函式

0.目錄 1.智慧指標 2.轉換建構函式 3.型別轉換函式 4.小結 1.智慧指標 記憶體洩漏（臭名昭著的Bug）： 動態申請堆空間，用完後不歸還 C++語言中沒有垃圾回收機制 指標無法控制所指堆空間的生命週期 我們需要什麼： 需要一個特殊的指標 指標生命週期結束

C++解析(20)：智能指針與類型轉換函數

font 類類型 有一個 安全 ont 運行 root 工作 sign 0.目錄 1.智能指針 2.轉換構造函數 3.類型轉換函數 4.小結 1.智能指針 內存泄漏（臭名昭著的Bug）： 動態申請堆空間，用完後不歸還 C++語言中沒有垃圾回收機制 指針無法控制所指堆空間的

C++解析(23)：多型與C++物件模型

0.目錄 1.多型 2.C++物件模型 3.繼承物件模型 4.多型物件模型 5.小結 1.多型 面向物件中期望的行為： 根據實際的物件型別判斷如何呼叫重寫函式 父類指標（引用）指向 父類物件則呼叫父類中定義的函式 子類物件則呼叫子類中定義的重寫函式

C++筆記 第四十二課 型別轉換函式（下）類型別---其他型別---狄泰學院

如果在閱讀過程中發現有錯誤，望評論指正，希望大家一起學習，一起進步。 學習C++編譯環境：Linux 第四十二課 型別轉換函式（下）類型別—>其他型別 1.問題 類型別是否能夠型別轉換到普通型別？用編譯器測試—可以，引入新的語法規則 2.型別轉換函式 C++類中

C++筆記 第四十一課 型別轉換函式（上）普通型別--類型別---狄泰學院

如果在閱讀過程中發現有錯誤，望評論指正，希望大家一起學習，一起進步。 學習C++編譯環境：Linux 第四十一課 型別轉換函式（上）普通型別–>類型別 1.再論型別轉換 標準資料型別之間會進行隱式的型別安全轉換 轉換規則如下： 41-1 有趣的隱式型別轉換 #

2，More Effective C++——條款5（謹慎使用定製“型別轉換函式”）

1 隱式型別轉換 C++中允許如下3種形式的隱式型別轉換： 1. 基本型別隱式型別轉換： int a = 10; double b = a; 2. 單引數構造建構函式 class Name { // 可以將char* 型別轉換成Name型別 Name(con

c++11： 智慧指標 shared_ptr & unique_ptr

一、背景 1. 堆記憶體、棧記憶體、靜態區記憶體 我們知道，靜態記憶體用來儲存區域性 static 物件、類 static 資料成員以及定義在函式之外的變數。而棧記憶體用來儲存定義在函式內的非 static 物件。 分配在靜態區或棧記憶體中的物件由編譯器自動建立和銷燬，對於棧

C++解析(12)：初始化列表與物件構造順序

0.目錄 1.類成員的初始化 2.類中的const成員 3.物件的構造順序 3.1 區域性物件的構造順序 3.2 堆物件的構造順序 3.3 全域性物件的構造順序 4.小結 1.類成員的初始化 類中是否可以定義const成員？ 下面的類定義是否合法？如果合法，ci的值是什麼，儲

C++解析(26)：函式模板與類模板

0.目錄 1.函式模板 1.1 函式模板與泛型程式設計 1.2 多引數函式模板 1.3 函式過載遇上函式模板 2.類模板 2.1 類模板 2.2 多引數類模板與特化 2.3 特化的深度分析 3.小結 1.函式模板 1.1 函式模板與泛型程式設計 C++中有幾

C++解析(26)：函數模板與類模板

null 並且 http 外部 asi 分類 工程 顯示調用 完全 0.目錄 1.函數模板 1.1 函數模板與泛型編程 1.2 多參數函數模板 1.3 函數重載遇上函數模板 2.類模板 2.1 類模板 2.2 多參數類模板與特化 2.3 特化的深度分析 3.小結 1

C++解析(29)：型別識別

0.目錄 1.型別識別 2.動態型別識別 3.型別識別關鍵字 4.小結 1.型別識別 在面向物件中可能出現下面的情況： 基類指標指向子類物件 基類引用成為子類物件的別名 靜態型別——變數（物件）自身的型別 動態型別——指標（引用）所指向物件的實際型別 2.

[C++] 智慧指標與迴圈引用

   1、智慧指標的出現       在我們寫程式的時候總會遇到一些需要new的問題，在沒有智慧指標的時候，我們只能收到的去delete，一旦我們忘記就會出現記憶體洩漏的問題。智慧指標的出現就是為了解決這一問題，讓我們new的物件，能夠在使用完畢之後自己delete，而不用

c++:分析智慧指標與發展歷史

智慧指標是RAII思想的一種產品，那麼什麼是RAII呢？ RAII：Resource Acquistion Is Initialization 資源分配就初始化，定義一個類來封裝資源的分配和釋放。 在建構函式裡完

C++：智慧指標

首先，為什麼需要智慧指標？ 來看下面這段程式碼 bool doSomething() { // 如果時間執行失敗了就返回false return false; } // 為了避免記憶體洩漏和檔案描述符洩漏,我們需要寫出以下這樣冗餘的程式碼

C++“準”標準庫Boost學習指南(1)：智慧指標Boost.smart_ptr

我們學習C++都知道智慧指標，例如STL中的std::auto_ptr，但是為什麼要使用智慧指標，使用它能帶給我們什麼好處呢？ 最簡單的使用智慧指標可以不會因為忘記delete指標而造成記憶體洩露。還有如果我們開發或者使用第三方的lib中的某些函式需要返回指標，這樣的返回的

C++深度探索系列：智慧指標(Smart Pointer) [二]

                                           深度探索智慧指標(Smart Pointer) 主題索引： 一、剖析C++標準庫智慧指標(std::auto_ptr)        1.Do you Smart Pointer?    2

C++智慧指標與類模板

開發十年，就只剩下這套架構體系了！ >>>   

c++11新特性實戰（二）：智慧指標

## c++11新特性實戰（二）：智慧指標 c++11添加了新的智慧指標，unique_ptr、shared_ptr和weak_ptr，同時也將auto_ptr置為廢棄(deprecated)。 但是在實際的使用過程中，很多人都會有這樣的問題： 1. 不知道三種智慧指標的具體使用場景 2. 無腦只使用

【C/C++開發】函式指標與回撥函式

C++很多類庫都喜歡用回撥函式，MFC中的定時器，訊息機制，hook機制等待，包括現在在研究的cocos2d-x中也有很多的回撥函式。 1.回撥函式 什麼是回撥函式呢？回撥函式其實就是一個通過函式指標呼叫的函式！假如你把A函式的指標當作引數傳給B函式，然後在B函式中通過A函式傳進來的這個指標

effective c++條款20：寧以pass-by-reference-to-const替換pass-by-value

1. 更高效 考慮如下的一個base class和derived class： class Base { private: std::string name; std::string address; public: Base(){} ~Base(){}