C++11 way to reset a struct to null?

Question

I am learning a physics library and it involves creating info structs and then passing them to initialiser functions:

btRigidBodyConstructionInfo rbInfo = (/*values...*/);
btRigidBody* rigidBody = new btRigidBody(rbInfo);

Now I want to reset the struct (null it) to reuse it. I found another question on SO which is identical, and the answer was either to create a zero-initialised temporary and set it to it, or after C++11:

rbInfo = {};

When I tried this I got the message:

"No operator "=" matches these operands.

I was confused and but then found out that this syntax attempts to call the default constructor (at least in my compiler (Visual Studio 2017)), and rbInfo doesn't haven't any. I have a feeling that that syntax does the same as:

rbInfo = btRigidBodyConstructionInfo{};

In this case is there no way to reset the struct without setting the individual members? I thought about memsetting, but that's a bad idea generally because there might be things like vtable pointers and such, right?

Answer 1

Your question sounds a bit like a small XY problem.

You state your goal is

Now I want to reset the struct (null it) to reuse it.

The X is "reuse the structure," but somehow a Y of "reset the structure" got mixed in. If all you want to do is reuse the structure, you can just do this:

btRigidBodyConstructionInfo rbInfo = (/*values...*/);
btRigidBody* rigidBody = new btRigidBody(rbInfo);

rbInfo = {/*new values...*/};

Or, if your compiler is too old to support that syntax, then:

rbInfo = btRigidBodyConstructionInfo(/*new values...*/);

Answer 2

In C++ variables have values, not references, backing them. This is distinct from most other languages, where variables are references to possible values.

Some languages have simple data be actual values, while classes are always references. Few languages have class objects whose variables are actually the value of the class.

There is no generic "null" state for (all kinds of) values. Values, in general, are not "nullable". In C++ you can enforce that a type never holds byte values of 0. For example:

class Foo {
  Foo(){}
private:
  int x = -1;
};

this really simple class can never have its x value be 0.

For some types of values, you can literally zero them out (set all their bytes to zero). For other types of values, this is explicitly not allowed.

A concept similar to being nullable is being constructible from zero arguments. If that is the case, and you have a copy or move assign operator, then

foo = {};

will (usually) assign to foo a temporary zero-argument constructed Foo (assuming foo is of type Foo, and sane operator= overloads).

If your type btRigidBodyConstructionInfo has no zero-argument constructor, and is not an aggregate, then you cannot do foo = {}; if foo is btRigidBodyConstructionInfo foo;.

You can do foo = {construction arguments};, and assuming a sane operator= it will do what you want.

If you want a nullable value type, consider boost::optional or std::optional.

std::optional<btRigidBodyConstructionInfo> foo{ std::in_place, /*values...*/ };

then use *foo at point of use. Later, you can null the value by doing foo={};.

To repopulate it, you can either use

foo = {std::in_place, /*values...*/};

or

foo.emplace( /*values...*/ );

you can test if the foo is nulled by doing if (!foo), and you can access the value (undefined behavior if it is null) by *foo.

This behaves a bit like a pointer, but it is actually a value type.