Compiler behavior regarding class objects I don't understand - c++

Question

I'm a noob and still learning the c++ language. The thing is, doing an exercise from a book, I've come across a compiler behavior I don't understand.
The header file.
// 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
The class implementation.
// 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);
}
The main file.
// 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;
}
As you may have guessed, Stock is the class and I've created non-default constructor and destructor to display messages to see when they "act".
Here's the output from program execution:
Using (non default) constructors to create new objects
Constructor using NanoSmart called
Company: NanoSmart Shares: 12
Share Price: $20.000 Total Worth: $240.00
Constructor using Boffo Objects called
Company: Boffo Objects Shares: 2
Share Price: $2.000 Total Worth: $4.00
Assigning stock1 to stock2:
Listing stock1 and stock2:
Company NanoSmart Shares: 12
Share Price: $20.000 Total Worth: $240.00
Company NanoSmart Shares: 12
Share Price: $20.000 Total Worth: $240.00
Using a constructor to reset an object
Constructor using Nifty Foods called
Bye, NanoSmart! // Why? Shouldn't it be Bye, Nifty Foods?
Revised stock1:
Company: Nifty Foods Shares: 10
Share Price: $50.000 Total Worth: $500.00
Done
Bye, NanoSmart!
Bye, Nifty Foods!
In this specific line:
stock1 = Stock("Nifty Foods", 10, 50.0); // temp object
Shouldn't the compiler:
1. Create a temporary object with the constructor
2. Assign that object to the stock1 object
3. Destroy the temporary object
Shouldn't the message say Nifty Foods instead of NanoSmart?
I don't get it. Any help?

Answer 1

You don't have a assignment operator defined, so if you are using a C++11 compiler, it probably uses the move assignment operator, which swaps the objects and then deletes the new contents of the temp object, which used to be in stock1.
At least, that is the observed behavior. ecatmur is correct, however, that your class should not have received an implicit move assignment operator. That might of course be a compiler bug.

Answer 2

You haven't written a copy assignment operator Stock::operator=(const Stock &) or move assignment operator Stock::operator=(Stock &&), so your assignment stock1 = Stock("Nifty Foods", 10, 50.0); will invoke an implicitly defined copy/move assignment operator:
c++11
12.8 Copying and moving class objects [class.copy]
18 - If the class definition does not explicitly declare a copy assignment operator, one is declared implicitly. If
the class definition declares a move constructor or move assignment operator, the implicitly declared copy
assignment operator is defined as deleted; otherwise, it is defined as defaulted (8.4).
28 - The implicitly-defined copy/move assignment operator for a non-union class X performs memberwise copy-
/move assignment of its subobjects.
Because your class has a user-defined destructor, the move assignment operator will not be implicitly defined (12.8:20), so the implicitly defined copy assignment operator will be called:
20 - If the definition of a class X does not explicitly declare a move assignment operator, one will be implicitly
declared as defaulted if and only if [...]
X does not have a user-declared destructor
Thus the Stock("Nifty Foods", 10, 50.0) will be memberwise copied into stock1 and then destructed; so the message displayed will be "Bye, Nifty Foods!".
Here's a 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");
}
Output:
S(a)
S(b)
~S(b)
~S(b)

Answer 3

I don't see anything immediately wrong with your code, but you should probably implement a copy-constructor and assignment operator anyway, just to be sure that copying is performed correctly.
something like this:
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;
}
// ...
};
For more information about copy-constructors, see e.g. this Wikipedia article. For the assignment operator, see e.g. this article.