日本国产欧美大码a视频,黄色片一级片视频

[導讀]一、轉換構造函數的學習： 1、回憶數據類型轉換：在平時寫代碼的時候，最怕的就是那種隱式數據類型轉換了，一不小心，軟件就bug不斷；而顯式數據類型（一般是程序自己去強制類型轉換，這個是我們能夠明顯的識別和掌控的）。為此我們這里總結了一副隱式類型轉

一、轉換構造函數的學習：

1、回憶數據類型轉換：

在平時寫代碼的時候，最怕的就是那種隱式數據類型轉換了，一不小心，軟件就bug不斷；而顯式數據類型（一般是程序自己去強制類型轉換，這個是我們能夠明顯的識別和掌控的）。下面，我們來幾個隱式轉換的例子：

代碼版本一：

#include #include int main()
{
     short s ='a';
     unsigned int ui = 100;
     int i = -200;
     double d = i;

     std::cout<<"d =" << d <"ui= "<if((ui+i)>0)
     {
          std::cout<<"Postive"<else {
        std::cout<<"Negative"<return 0;
}

輸出結果：

root@txp-virtual-machine:/home/txp# ./a.out d =-200
ui= 100
Postive

注解：這里我們明顯發(fā)現(-200+100)還是大于0，這顯然不符合正常人的思維了；所以我們仔細分析一下，發(fā)現這里肯定是進行了隱式轉換了，為此我們再加一條語句看看(ui+i)的值到底是多少：

代碼版本二：

#include #include int main()
{
     short s ='a';
     unsigned int ui = 100;
     int i = -200;
     double d = i;

     std::cout<<"d =" << d <"ui= "<if((ui+i)>0)
     {
        std::cout<<"(ui+i) = "<"Postive"<else {
        std::cout<<"Negative"<return 0;
}

輸出結果：

root@txp-virtual-machine:/home/txp# ./a.out d =-200
ui= 100
(ui+i) = 4294967196
Postive

注解：通過打印(ui+i)的值我們發(fā)現，i原本是int數據類型，這里隱式轉換成無符號的數據類型了

為了讓大家更加理解隱式的轉換，我們下面再來一個例子：

代碼版本三：

#include #include int main()
{
     short s ='a';
     unsigned int ui = 100;
     int i = -200;
     double d = i;

     std::cout<<"d =" << d <"ui= "<if((ui+i)>0)
     {
        std::cout<<"(ui+i) = "<"Postive"<else {
        std::cout<<"Negative"<"sizeof(s+'b') = "<'b')<return 0;
}

輸出結果：

root@txp-virtual-machine:/home/txp# g++ test.cpp root@txp-virtual-machine:/home/txp# ./a.out d =-200
ui= 100
(ui+i) = 4294967196
Postive
sizeof(s+'b') = 4

注解：這里我們發(fā)現sizeof出來的內存大小是4個字節(jié)大??；其實這里編譯器把short和char類型的都轉換int類型了，所以最終兩個int數據相加，所占的內存大小就是int類型了。

所以咋們平時在寫代碼的時候，腦袋里面要有這種寫代碼謹慎的思維，防止出現這種隱式轉換的情況出現，養(yǎng)成寫代碼的好習慣

2、普通類型與類類型之間能否進行類型轉換，類類型之間又是否能夠類型轉換呢？

為了說明這些問題，咋們通過實際的代碼測試來看看啥情況：

代碼：普通類型轉換成類類型

#include #include class Test{

public: Test()
    {

    }
    Test(int i)
    {

    }
};

int main()
{
     Test t;

     t =6; 從 C 語言角度，這里將 5 強制類型轉換到 Test 類型，只不過編譯器 在這里做了隱式類型轉換 return 0;
}

輸出結果(顯示可以編譯通過)

root@txp-virtual-machine:/home/txp# g++ test.cpp root@txp-virtual-machine:/home/txp# ./a.out

代碼類類型轉換為普通類型

#include #include class Test{

public: Test()
    {

    }
    Test(int i)
    {

    }
};

int main()
{
     Test t;

     int i = t; return 0;
}

輸出結果（沒有編譯通過）

root@txp-virtual-machine:/home/txp# g++ test.cpp test.cpp: In function ‘int main()’:
test.cpp:21:14: error: cannot convert ‘Test’ to ‘int’ in initialization
      int i = t;
              ^

代碼類類型與類類型之間的轉換：

#include #include class Value{

};


class Test{

public: Test()
    {

    }
    Test(int i)
    {

    }
};

int main()
{
     Test t;
     Value i;

     t=i; return 0;
}

輸出結果（暫時還是不行，編譯不通過）：

root@txp-virtual-machine:/home/txp# g++ test.cpp test.cpp: In function ‘int main()’:
test.cpp:27:7: error: no match for ‘operator=’ (operand types are ‘Test’ and ‘Value’)
      t=i;
       ^
test.cpp:27:7: note: candidate is:
test.cpp:9:7: note: Test& Test::operator=(const Test&)
 class Test{
       ^
test.cpp:9:7: note:   no known conversion for argument 1 from ‘Value’ to ‘const Test&’

說明：上面的例子，我們只是簡單的按照實際角度出發(fā)，發(fā)現確實有寫轉換行不通。那么真理到底是怎樣的？我們接著往下看

3、轉換構造函數出廠：

我們前面學習過構造函數，構造函數它可以定義不同類型的參數；但是我們今天這里所說的轉換構造函數的定義時這樣的：

有且僅有一個參數
參數是基本類型
參數是其它類型

接著我們對上面的普通數據類型轉換類類型的代碼進行分析：

#include #include class Test{

public: Test()
    {

    }
    Test(int i)
    {

    }
};

int main()
{
     Test t;

     t =6; //從 C 語言角度，這里將 5 強制類型轉換到 Test 類型，只不過編譯器 在這里做了隱式類型轉換 return 0;
}

分析：

上面的Test(int i )就是一個轉換構造函數，所以我們上面的這句隱式轉換語句：

t =6

這里其實發(fā)生了我們剛才說的利用了轉換構造函數，把6轉換成Test(6),而這樣寫就會產生一臨時對象，所以就可以進行賦值了；但是在現在的技術發(fā)展中，肯定是不希望出現這種要人去防止這隱式轉換，所以在c++中有了新技術來防止出現隱式轉換：

工程中通過explicit關鍵字杜絕編譯器的轉換嘗試
轉換構造函數被explicit修飾只能進行顯示轉換(也就是強制類型轉換)

代碼實踐一：

#include #include class Test{

public: Test()
    {

    }
   explicit Test(int i)
    {

    }
};

int main()
{
     Test t;

     t =6; return 0;
}

輸出結果：

root@txp-virtual-machine:/home/txp# g++ test.cpp test.cpp: In function ‘int main()’:
test.cpp:21:8: error: no match for ‘operator=’ (operand types are ‘Test’ and ‘int’)
      t =6;
        ^
test.cpp:21:8: note: candidate is:
test.cpp:4:7: note: Test& Test::operator=(const Test&)
 class Test{
       ^
test.cpp:4:7: note:   no known conversion for argument 1 from ‘int’ to ‘const Test&’

注解：這里顯示不能這樣轉換

代碼實踐二(進行顯示轉換)：

#include #include class Test{

public: Test()
    {

    }
   explicit Test(int i)
    {

    }
};

int main()
{
     Test t;

     t =static_cast(6); return 0;
}

輸出結果(編譯通過)：

root@txp-virtual-machine:/home/txp# g++ test.cpp root@txp-virtual-machine:/home/txp#

4、小結：

轉換構造函數只有一個參數
轉換構造函數的參數類型是其它類型
轉換構造函數在類型轉換時被調用
隱式類型轉換是工程中bug的重要來源
explicit關鍵字用于杜絕隱式類型轉換

二、類型轉換函數：

1、類類型轉換普通類型：

在我們上面通過代碼測試發(fā)現不行，那么是真的不行嗎，事實是可以進行轉換的，不過要用到我們現在c++里面的類型轉換函數(它用于將類對象轉換為其它類型)，類型轉換的語法如下：

operator Type()
{
    Type ret; return ret;

}

代碼實踐：

#include #include class Test{

public: Test()
    {

    }
   operator int()
   {

    }
};

int main()
{
     Test t;
     int i =t; return 0;
}

輸出結果(編譯沒有報錯):

root@txp-virtual-machine:/home/txp# g++ test.cpp root@txp-virtual-machine:/home/txp#

注：

與轉換構造函數具有同等的地位
使得編譯器有能力將對象轉化為其它類型
編譯器能夠隱式的使用類型轉換函數

2、類類型之間的轉換：

這個問題也是之前我們上面簡單的測試，不能進行類類型之間的轉換；現在我們學習了類型轉換函數，是可以進行轉換的：

代碼版本一：

#include #include 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;
    }
/*工程上通過以下方式；
  Value toValue()
  {
      Value ret; return ret;
  
  }
};

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

輸出結果(編譯通過):

root@txp-virtual-machine:/home/txp# g++ test.cpp root@txp-virtual-machine:/home/txp#

注意：這里還有一種讓編譯器犯難的轉換寫法；我們上面這樣寫是用explicit關鍵字屏蔽了Value類里面的隱式轉換，所以不會犯難，下面是犯難的代碼示例：

#include #include 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@txp-virtual-machine:/home/txp# g++ test.cpp test.cpp: In function ‘int main()’:
test.cpp:42:15: error: conversion from ‘Test’ to ‘Value’ is ambiguous
     Value v = t;
               ^
test.cpp:41:10: note: candidates are:
     Test t(100);
          ^
test.cpp:31:5: note: Test::operator Value()
     operator Value()
     ^
test.cpp:14:6: note: Value::Value(Test&)
      Value(Test& t)

3、小結：