关于我不理解的类对象的编译器行为

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文章 。 有关赋值运算符，请参见本文 。