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！ // 为什么？不应该是Bye，Nifty Foods？
  修改了stock1：
  公司：Nifty Foods股票：10
   股价：$ 50.000总价值：$ 500.00
  做
  再见，NanoSmart！
  再见，Nifty Foods！

在这一具体路线中：

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

不应该是编译器：
1.使用构造函数
创建临时对象 2.将该对象分配给stock1对象
3.销毁临时对象

消息不应该是Nifty Foods而不是NanoSmart吗？

我不明白。有什么帮助吗？

Answer 1

您没有定义赋值运算符，因此如果您使用的是C ++ 11编译器，它可能会使用移动赋值运算符，该运算符交换对象然后删除临时对象的新内容在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 - 如果类定义没有明确声明一个复制赋值运算符，则会隐式声明一个。如果   类定义声明了一个移动构造函数或移动赋值运算符，即隐式声明的副本   赋值运算符被定义为已删除;否则，它被定义为默认值（8.4）   28 - 非联合类X的隐式定义的复制/移动赋值运算符执行成员复制 -   /移动其子对象的分配。

因为您的类具有用户定义的析构函数，所以不会隐式定义移动赋值运算符（12.8：20），因此将调用隐式定义的复制赋值运算符：

20 - 如果类X的定义没有明确声明一个移动赋值运算符，那么将隐式地   当且仅当[...]
时宣布为违约


X没有用户声明的析构函数

因此Stock("Nifty Foods", 10, 50.0)会被成员复制到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;
        }

    // ...
};

有关复制构造函数的详细信息，请参阅例如this Wikipedia article。对于赋值运算符，请参阅例如this article

关于类对象的编译器行为我不明白

3 个答案:

12.8复制和移动类对象[class.copy]