This browser is no longer supported.
Upgrade to Microsoft Edge to take advantage of the latest features, security updates, and technical support.
I'm writing in C++ using Visual Studio and ran in to a problem I don't understand at all: I added a constant integer to one of my objects which caused the compiler to ?delete the constructor?
Removing 'const' from the integer allows the constructor to survive. Using 'const' and creating a pointer to the object on the heap also allows the constructor to survive.
It says that the function was declared implicitly, yet I've very explicitly written the constructor for the object.
// error as shown below
game = Game();
C++ function "Game::operator=(const Game &)" (declared implicitly) cannot be referenced -- it is a deleted function
// perfectly fine
Game* game = new Game();
So, it seems there's a lot more going on under the hood than creating an object on the stack vs. the heap. I would like to know what is actually happening and why the compiler is declaring its own functions then deleting them in the first case.
Thanks for any information.
If Game contains a constant member, then the object (game variable) cannot be altered by operations like game = game2 or game = Game() (where Game() can be considered an anonymous variable). In this case the default '=' operator, which overwrites members, cannot be provided by compiler.
The new Game creates a new object on the heap, then the pointer is assigned to Game* game. The object is not copied and the '=' operator of Game is not implied.
![](data:image/svg+xml, %3Csvg xmlns='http://www.w3.org/2000/svg' height='64' class='font-weight-bold' style='font: 600 30.11764705882353px "SegoeUI", Arial' width='64'%3E%3Ccircle fill='hsl(201.6, 57.00000000000001%, 29%)' cx='32' cy='32' r='32' /%3E%3Ctext x='50%25' y='55%25' dominant-baseline='middle' text-anchor='middle' fill='%23FFF' %3EMY%3C/text%3E%3C/svg%3E)
Can you provide a minimal reproducible example without personal privacy?
game = Game();
The above line of code is calling the Game class copy assignment operator ( the deleted function). The compiler complains because a const member variable of type int can be initialized but does not allow for assignment of values (otherwise it wouldn't be const).
Game* game = new Game();
This line of code creates a Game object on the heap and assigns its address to the *game pointer variable. There is no attempt to copy anything into a const member variable.
Game game = Game();
The line of code creates a Game object on the stack and uses a copy constructor. If your code doesn't contain a copy constructor for the Game class the compiler provides one for you. If you tried to write a copy constructor like this
Game(const Game& rhs)
{
i = rhs.i;
}
private:
const int i;
then the compiler would complain about the assignment to a const variable (error C2789: 'Game::i': an object of const-qualified type must be initialized). However, if you wrote a copy constructor like this
Game(const Game& rhs) : i(rhs.i)
{
}
private:
const int i;
then the compiler is OK since the const member variable is being initialized.
Thanks for the response!
So, what I'm getting is that the compiler is trying do a copy command, which includes an assignment command on a constant, which is of course invalid.
However, since it is constant, it has never changed from the initialized value, so the copy command for this member is redundant. E.g.
const int x = 6; // initialized to value
x = 6; // completely unnecessary and invalid
So, the compiler should ignore this line altogether (since assigned value is the same as assignment value), but I guess the build just fails instead of realizing that the operation can be safely ignored, meaning we have to write our own copy constructor.
Which would be understandable, except there's no need for a copy at all. I don't understand why this is a copy, or even what is being copied. All I wanted is a new "game" to be constructed and assigned to a variable for access. The pointer works fine, it just seems like an unnecessary pointer to manage.
There is literally no game object in existence before the line is run, so there is nothing to copy. I suppose the crux of the problem here is what exactly is this line doing?
Game game = Game();
You gave the fairly standard explanation of "creates an object on the stack" then added in "and uses a copy constructor." But what is it copying, and from where to where, and ultimately why?
Game game = Game();
I think what is confusing here is that the compiler is using an optimization (copy elision) to avoid creating a temporary object (the call to Game() on the right side of the statement) and then using the copy constructor to copy the temporary into the game object on the left side of the statement. Perhaps clearer examples of copy construction vs. assignment (using non-const int variable) would be
class Test
{
public:
Test() : i(42) //Default constructor
{
}
Test(int x) : i(x)
{
}
Test(const Test& rhs) : i(rhs.i) //Copy constructor
{
}
Test operator=(const Test& rhs) //Assignment operator
{
i = rhs.i;
return *this;
}
int i;
};
// and in a console application
Test obj; // default constructed
std::cout << obj.i << std::endl;
Test obj2(100);
std::cout << obj2.i << std::endl;
obj = obj2; // assignment operator
std::cout << obj.i << std::endl;
Test obj3 = obj2; //Copy constructor
std::cout << obj3.i << std::endl;