What can be instantiated?

Question

What types in C++ can be instantiated?

I know that the following each directly create a single instance of Foo:

Foo bar;
Foo *bizz = new Foo();

However, what about with built-in types? Does the following create two instances of int, or is instance the wrong word to use and memory is just being allocated?

int bar2;
int *bizz2 = new int;

What about pointers? Did the above example create an int * instance, or just allocate memory for an int *?

Would using literals like 42 or 3.14 create an instance as well?

I've seen the argument that if you cannot subclass a type, it is not a class, and if it is not a class, it cannot be instantiated. Is this true?

Answer 1

So long as we're talking about C++, the only authoritative source is the ISO standard. That doesn't ever use the word "instantiation" for anything but class and function templates.

It does, however, use the word "instance". For example:

An instance of each object with automatic storage duration (3.7.2) is associated with each entry into its block.

Note that in C++ parlance, an int lvalue is also an "object":

The constructs in a C++ program create, destroy, refer to, access, and manipulate objects. An object is a region of storage.

Since new clearly creates regions of storage, anything thus created is an object, and, following the precedent of the specification, can be called an instance.

Answer 2

As far as I can tell, you're really just asking about terminology here. The only real distinction made by the C++ standard is POD types and non-POD types, where non-POD types have features like user-defined constructors, member functions, private variables, etc., and POD types don't. Basic types like int and float are of course PODs, as are arrays of PODs and C-structs of PODs.

Apart from (and overlapping with) C++, the concept of an "instance" in Object-Oriented Programming usually refers to allocating space for an object in memory, and then initializing it with a constructor. Whether this is done on the stack or the heap, or any other location in memory for that matter, is largely irrelevant.

However, the C++ standard seems to consider all data types "objects." For example, in 3.9 it says:

"The object representation of type T is the sequence of N unsigned char objects taken up by the object of type T, where N equals sizeof(T)..."

So basically, the only distinction made by the C++ standard itself is POD versus non-POD.