What is different between object and variable in c plus plus?

Answer 1

A variable is simply a named value where the value is not constant -- meaning it can be changed at any time.

A pointer is a variable (or a constant) that can store a memory address and provides indirect access to that memory address. It is called a pointer because it is said to "point to" the memory address it contains. A pointer that doesn't actually point at anything should store the value zero (represented by the constant NULL). When you allocate memory dynamically, you must maintain at least one pointer to that memory in order to release the memory back to the system, which is achieved by deleting the pointer, and then nullifying the pointer, or pointing it to another allocation. Pointers can also be typed, such that the memory address being pointed is treated as if it were that type, thus a pointer to a char can be used to determine the value of each individual byte in a multi-byte value, such as an int, simply by incrementing its stored address to traverse the individual bytes. By the same token an array of 4 bytes can be treated as if it were a single 32-bit value, simply by pointing at the first byte using a pointer with type int. Note that a pointer can only physically point at one byte at a time, but its type allows you to access one or more contiguous bytes according to its type, thus incrementing the pointer's stored address will advance the pointer by the size of its type. Thus a pointer to int will automatically increment (or decrement) by sizeof(int) bytes.

Pointers can also point at other pointers, adding extra levels of indirection. This is most useful when you need to pass a pointer to a function by reference, since all pointers are always passed by value. However, passing a pointer to a pointer is the same as passing the pointer being pointed at by reference, which allows the pointer itself to be manipulated, not just what it points at. Pointer to pointer types are also useful when allocating large dynamic arrays as they allow the array to be allocated non-contiguously as a series of smaller, separate arrays. This uses more memory overall, but allocating many smaller arrays is far more likely to succeed where a large contiguous allocation could easily fail if a large enough block of free memory is not available.

Answer 2

In essence there is no difference. The underlying implementation is exactly the same. A variable is simply a memory allocation, the size of which is determined by the variable's type. The type could be a primitive (built-in) type, like int or char, or a more complex data type such as a structure or indeed a class type. An object is nothing more than a specific instance of a class type. But all are accessed by the name we give them -- which is simply an alias for the memory we allocated to the variable. They may appear quite different on the surface, but all are implemented in the same way: as a class of object.

Even the primitive types are implemented as objects:

int X = int(12); // int assignment using int class constructor.

Although much of the implementation is hidden from us, X is, in fact, an object of class type int. All the standard operators (+, -, &, etc) and type casts are implemented as operator overloads, but besides the constructors that's about as much access as we get to the underlying object. There is no member operator (.) and we cannot derive classes from primitives, but they are a class of object nonetheless.

Prior to C++, primitives were, of course, implemented quite differently. But in an object-oriented environment like C++, it makes sense to implement them as objects.