關於我不理解的類對象的編譯器行為

Question

我是菜鳥，仍在學習c ++語言。 事情是，從書中進行練習，我遇到了我不理解的編譯器行為。

頭文件。

// stock10.h -- Stock class declaration with constructors, destructor added

#ifndef STOCK10_H_
#define STOCK10_H_

#include <string>

class Stock
{
private:
    std::string company;
    long shares;
    double share_val;
    double total_val;
    void set_tot() { total_val = shares * share_val; }
public:
    // two constructors
    Stock(); // default constructor
    Stock(const std::string & co, long n = 0, double pr = 0.0);
    ~Stock(); // noisy destructor
    void buy(long num, double price);
    void sell(long num, double price);
    void update(double price);
    void show();
};

#endif

類的實現。

// stock10.cpp -- Stock class with constructors, destructor added

#include <iostream>
#include "stock10.h"

// constructors (verbose versions)
Stock::Stock() // default constructor
{
    std::cout << "Default constructor called\n";
    company = "no name";
    shares = 0;
    share_val = 0.0;
    total_val = 0.0;
}

Stock::Stock(const std::string & co, long n, double pr)
{
    std::cout << "Constructor using " << co << " called\n";
    company = co;
    if (n < 0)
    {
        std::cout << "Number of shares can’t be negative; "
                  << company << " shares set to 0.\n";
        shares = 0;
    }
    else
        shares = n;
    share_val = pr;
    set_tot();
}

// class destructor
Stock::~Stock() // verbose class destructor
{
    std::cout << "Bye, " << company << "!\n";
}

// other methods
void Stock::buy(long num, double price)
{
    if (num < 0)
    {
        std::cout << "Number of shares purchased can’t be negative. "
                  << "Transaction is aborted.\n";
    }
    else
    {
        shares += num;
        share_val = price;
        set_tot();
    }
}

void Stock::sell(long num, double price)
{
    using std::cout;
    if (num < 0)
    {
        cout << "Number of shares sold can’t be negative. "
             << "Transaction is aborted.\n";
    }
    else if (num > shares)
    {
        cout << "You can’t sell more than you have! "
             << "Transaction is aborted.\n";
    }
    else
    {
        shares -= num;
        share_val = price;
        set_tot();
    }
}

void Stock::update(double price)
{
    share_val = price;
    set_tot();
}

void Stock::show()
{
    using std::cout;
    using std::ios_base;
    // set format to #.###
    ios_base::fmtflags orig =
        cout.setf(ios_base::fixed, ios_base::floatfield);
    std::streamsize prec = cout.precision(3);
    cout << "Company: " << company
         << " Shares: " << shares << '\n';
    cout << " Share Price: $" << share_val;
    // set format to #.##
    cout.precision(2);
    cout << " Total Worth: $" << total_val << '\n';
    // restore original format
    cout.setf(orig, ios_base::floatfield);
    cout.precision(prec);
}

主文件。

// usestok1.cpp -- using the Stock class
// compile with stock10.cpp

#include <iostream>
#include "stock10.h"

int main()
{
    {
        using std::cout;
        cout << "Using (non default) constructors to create new objects\n";
        Stock stock1("NanoSmart", 12, 20.0); // syntax 1
        stock1.show();
        Stock stock2 = Stock ("Boffo Objects", 2, 2.0); // syntax 2
        stock2.show();

        cout << "Assigning stock1 to stock2:\n";
        stock2 = stock1;
        cout << "Listing stock1 and stock2:\n";
        stock1.show();
        stock2.show();

        cout << "Using a constructor to reset an object\n";
        stock1 = Stock("Nifty Foods", 10, 50.0); // temp object
        cout << "Revised stock1:\n";
        stock1.show();
        cout << "Done\n";
    }
    std::cin.get();
    return 0;
}

您可能已經猜到，Stock是類，我創建了非默認的構造函數和析構函數以顯示消息以查看它們何時“起作用”。

這是程序執行的輸出：

使用（非默認）構造函數創建新對象
使用NanoSmart的構造函數稱為
公司：NanoSmart分享：12
股價：$ 20.000總價值：$ 240.00
使用Boffo對象的構造函數稱為
公司：Boffo Objects分享：2
股價：$ 2.000總價值：$ 4.00
將stock1分配給stock2：
列出stock1和stock2：
公司NanoSmart份額：12
股價：$ 20.000總價值：$ 240.00
公司NanoSmart份額：12
股價：$ 20.000總價值：$ 240.00
使用構造函數重置對象
使用Nifty Foods的構造函數稱為
再見，NanoSmart！ // 為什么？ 那不應該是Nifty Foods再見嗎？
修改后的庫存1：
公司：Nifty Foods股票：10
股價：$ 50.000總價值：$ 500.00
完成
再見，NanoSmart！
再見，漂亮的食物！

在此特定行中：

stock1 = Stock("Nifty Foods", 10, 50.0); // temp object

編譯器不應該：
1.使用構造函數創建一個臨時對象
2.將該對象分配給stock1對象
3.銷毀臨時對象

消息不應該說Nifty Foods而不是NanoSmart嗎？

我不明白 有什么幫助嗎？

Answer 1

您沒有定義賦值運算符，因此，如果您使用的是C ++ 11編譯器，則它可能會使用move賦值運算符，該運算符交換對象，然后刪除temp對象的新內容，該內容以前在stock1 。

至少，這是觀察到的行為。 ecatmur是正確的，但是，您的班級不應收到隱式的移動分配運算符。 這當然可能是編譯器錯誤。

Answer 2

您尚未編寫副本賦值運算符Stock::operator=(const Stock &)或移動賦值運算符Stock::operator=(Stock &&) ，因此您的賦值stock1 = Stock("Nifty Foods", 10, 50.0); 將調用一個隱式定義的復制/移動賦值運算符：

C ++ 11

12.8復制和移動類對象[class.copy]

18-如果類定義未明確聲明一個副本分配運算符，則隱式聲明一個。 如果類定義聲明了move構造函數或move賦值運算符，則隱式聲明的副本賦值運算符將定義為delete； 否則，將其定義為默認值（8.4）。
28-非統一類X的隱式定義的復制/移動分配操作符對其子對象執行成員式復制/移動分配。

由於您的類具有用戶定義的析構函數，因此不會隱式定義移動分配運算符（12.8：20），因此將調用隱式定義的副本分配運算符：

20-如果類X的定義未明確聲明移動分配運算符，則當且僅當[...]

• X沒有用戶聲明的析構函數

因此， Stock("Nifty Foods", 10, 50.0) stock1 Stock("Nifty Foods", 10, 50.0)將被stock1成員復制到stock1 ，然后銷毀； 因此顯示的消息將是"Bye, Nifty Foods!" 。

這是一個SSCCE：

#include <iostream>
#include <string>
struct S {
    std::string s;
    S(const std::string &s): s(s) { std::cout << "S(" << s << ")\n"; }
    ~S() { std::cout << "~S(" << s << ")\n"; }
};
int main() {
    S a("a");
    a = S("b");
}

輸出：

S(a)
S(b)
~S(b)
~S(b)

Answer 3

我沒有發現您的代碼有什么立即出現的問題，但是無論如何您都應該實現一個復制構造函數和賦值運算符，以確保正確執行復制。

像這樣的東西：

class Stock
{
    // ...

public:
    // ...

    Stock(const Stock &other)
        : company(other.company), shares(other.shares),
          share_val(other.share_val), total_val(other.total_val)
        { }

    Stock &operator=(const Stock &other)
        {
            company   = other.company;
            shares    = other.shares;
            share_val = other.share_val;
            total_val = other.total_val;

            return *this;
        }

    // ...
};

有關復制構造函數的更多信息，請參見例如Wikipedia文章 。 有關賦值運算符，請參見本文 。