2. 程式人生 > >C++解析(20)：智能指針與類型轉換函數

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

阿新 • • 發佈：2018-12-08
font 類類型 有一個 安全 ont 運行 root 工作 sign

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;
}

運行結果為：

[root@bogon Desktop]# g++ test.cpp
[root@bogon 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;
}

運行結果為：

[root@bogon Desktop]# g++ test.cpp
[root@bogon 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;
}

運行結果為：

[root@bogon Desktop]# g++ test.cpp
[root@bogon 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;
}

運行結果為：

[root@bogon Desktop]# g++ test.cpp
[root@bogon 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;
}

運行結果為：

[root@bogon Desktop]# g++ test.cpp
[root@bogon 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;
}

報錯信息為：

[root@bogon 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)：智能指針與類型轉換函數

相關推薦

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

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

MOOC清華《面向對象程序設計》第8章：智能指針與引用計數實驗

cst .com xtu w3c www. use sina com wxs s36aj3靖錘端垂淖洶http://docstore.docin.com/gxqnm86068a3350米虜姿椒蝕蛋http://weibo.com/u/6195707998rfg9h8劫咨鋼咆

【c++工程實踐】智能指針

現在 app apt cycle cpp adr RM 設計 HA 一、智能指針簡介 a smart pointer is an abstract data type that simulates a pointer while providing added featur

C++學習筆記5_智能指針

ret 使用 delete 智能 模板 public del () let 1. 一般的指針int main(void){ int *p=new int; *p=20; delete p; return 0;}智能指針能自動回收#include<memory>

C++_智能指針模板類

另一個 temp 運算符 func 避免 執行 它的 移動構造函數 stl算法 智能指針是行為類似於指針的類對象，但這種對象還有其他功能。 本節介紹三個可幫助管理動態內存分配的智能指針模板（auto_ptr、unique_ptr和shared_ptr）。 void re

C++11 shared_ptr（智能指針）詳解

space 詳解 .net 註意 變量 turn int 出錯 構造 要確保用 new 動態分配的內存空間在程序的各條執行路徑都能被釋放是一件麻煩的事情。C++ 11 模板庫的 <memory> 頭文件中定義的智能指針，即 shared _ptr 模板，就是用來

21.C++- ++操作符重載、隱式轉換之explicit關鍵字、類的類型轉換函數

inf 我們 bug 操作符 臨時對象 blog 返回值 cnblogs 文章 ++操作符重載 ++操作符分為前置++和後置++,比如: ++a; a++; ++操作符可以進行全局函數或成員函數重載 重載前置++操作符不需要參數 重載後置++操作符需要一個int類型的占

C++筆記(12)：動態內存和智能指針

style round 運算 span tro 運算符 delet 庫函數 針對 　　　　　　　　　　　　　　　　　　　　　　　　　　動態內存和智能指針 動態內存： 　　1.針對堆裏面存放的對象 　　2.使用new delete運算符 　　3.智能指針：shared_ptr

C++相關：動態內存和智能指針

數量 網絡 隱式 執行 動態分配 int 弱引用 支持 相關操作 前言 在C++中，動態內存的管理是通過運算符new和delete來完成的。但使用動態內存很容易出現問題，因為確保在正確的時間釋放內存是及其困難的。有時候我們會忘記內存的的釋放，這種情況下就會產生內存泄露；有時

effective c++ 條款17：以獨立語句將newd對象置入智能指針

執行 順序 ID 條款17 隱式轉換 ive 遺失 解決 red 記住： 以獨立語句將newd對象存儲於智能指針內。如果不這樣做，一旦異常被拋出，有可能導致難以察覺的資源泄漏。 int priority(); void processWidget(std::tr1::

C++11中智能指針的原理、使用、實現

his animal something include expire another .cn 表現 oid 目錄 理解智能指針的原理 智能指針的使用 智能指針的設計和實現 1.智能指針的作用 C++程序設計中使用堆內存是非

C++智能指針剖析（下）boost::shared_ptr&其他

剖析 smart_ptr mage open log gin 內部使用 聲明 虛基類 1. boost::shared_ptr 前面我已經講解了兩個比較簡單的智能指針，它們都有各自的優缺點。由於 boost::scoped_ptr 獨享所有權，當我們真真需要復制智能指針時，

C++中的智能指針

int ans csdn 機制 lmin 廣泛 sans else ont 眾所周知。C++中對堆內存的申請與釋放全然由用戶來控制，這就造成用戶在使用的時候常常造成內存泄漏、野指針、反復釋放等常見的掛掉問題，所以我們有必要提供一套機制。使得用戶僅僅需申請對應的內存，不用

淺析C++中的智能指針

ron delete 存在 () 執行 釋放 release let 托管 一. 概述 由於最近比較多的接觸到這塊的代碼，因此有必要做個總結。 眾所周知，C/C++中的堆內存分配和釋放的方式主要是： malloc/free 以及 new/delete 等，但這些方式對程

C++ 智能指針學習

release new div str 我們 指針的引用 機制 cin 轉化 C++ Code 1234567891011121314151617181920212223242526272829303132333435363738394041424344454

C++ 智能指針詳解（轉）

include 復雜 測試類 信息 思想 編譯 應該 其他 eas C++ 智能指針詳解 一、簡介 由於 C++ 語言沒有自動內存回收機制，程序員每次 new 出來的內存都要手動 delete。程序員忘記 delete，流程太復雜，最終導致沒有 delete，異常導致程

【C/C++學院】0904-boost智能指針/boost多線程鎖定/哈希庫/正則表達式

llb int() strlen log 表數 uno cmp tip warning boost_array_bind_fun_ref Array.cpp #include<boost/array.hpp> #include <ios

C++之智能指針20170920

智能指針類 指針 n) emp argv before == 表示 解決 /***************************************************************************************************

C++智能指針

ring 標準 [] image space 創建 配對 優點 object 智能指針模板類 智能指針是行為類似於指針的類對象，但這種對象還有其他功能。本文章介紹三個可幫助管理動態內存分配的只能指針模板。先來看需要哪些功能以及這些功能是如何實現的。請看下面的函數 v

C++智能指針和普通指針轉換需要註意的問題

情況 問題 ret 臨時 share 沒有 崩潰 ostream 初始 指針是柄雙刃劍，用的好，就會威力倍增；用的稍有閃失，就會造成悲劇。 自從c++11引入智能指針shared_ptr後，我們似乎再也不用擔心new的內存沒有釋放之類的問題了，但是，這樣就萬無一失了嗎？ 答