What object in c plus plus?

Answer 1

An object is an instance of a class. A class is a user-defined data type from which we can instantiate objects of that class. We often use the terms object and variable interchangeably, however the term variable specifically refers to a named object (objects instantiated at compile time), as opposed to anonymous objects (instantiated at runtime). Built-in data types such as int, double and pointer types are not classes, thus instances of these types are simply known as variables. Built-in types are also part of the language (hence they are built-in) thus we don't need to include a header or a type definition in order to use them; they are immediately available. But to use an object we must first define its class or include the appropriate header that defines the class.

Answer 2

An array of objects in C++ is no different than an array of an elementary data type. class myclass {

... class declaration, definition,etc.

} class myclass myarrayofclasses[25]; // 25 elements of myclass myarrayofclasses[13].somemethod(); // see how easy it is

*(myarrayoflclasses+13)->somemethod(); // same thing with pointer syntax

Answer 3

You don't define an array, you declare and initialise an array. An array is a contiguous block of memory containing one or more elements of the same type (and size). Each element can be accessed via its memory address, which is an offset from the start of the array (such that element n can be found at address (n-1)*sizeof(element_type)), or more simply using the array subscript operator (such that element n can be found at index n-1). Arrays allow constant time random access to any element in the array.

Answer 4

An array of objects typically means an array of pointers to objects rather than an array of actual objects. Although it is possible to create an actual array of objects, this presents two problems. Firstly, all objects must be of the exact same class type; you cannot create arrays containing derivatives of that type. Secondly, the class itself must have a default constructor as well as some means of initialising the objects once they are instantiated. Both of these problems are linked to the fact that every object in the array must be instantiated at the same time as the array is instantiated, regardless of whether the array is instantiated at compile time (statically) or at runtime (dynamically).

The following is an example of a static array containing 10 static objects of type A:

struct A{};

A a[10];

Class A has no members, however we can see that the array is declared in the exact same way as we would declare an array of primitives (such as int, rather than A). However, let's flesh out class A so we can see exactly what goes on Behind the Scenes:

struct A{

// public data member

int m_data;

// public default constructor

A(int data=0):m_data(data){

std::cout<<"construct A [m_data="<<m_data<<"]"<<std::endl; }

};

A a[10];

Output:

construct A [m_data=0]

construct A [m_data=0]

construct A [m_data=0]

construct A [m_data=0]

construct A [m_data=0]

construct A [m_data=0]

construct A [m_data=0]

construct A [m_data=0]

construct A [m_data=0]

construct A [m_data=0]

As you can see, we've constructed 10 different objects but they all have the same data. In order to differentiate them we must initialise the data:

for (int i=0; i<10; ++i) {

a[i].m_data = i;

}

Thus when we instantiate an array of objects we must construct those objects in two stages: instantiate the array (which instantiates the objects) and then initialise those object.

By contrast, if we create an array of pointers to objects instead, we can see the construction is much more efficient. In the following example we'll use the exact same definition of A as used previously:

A* a[10];

for (int i=0; i<10; ++i) {

a[i]=new A(i);

}

Output:

construct A [m_data=0]

construct A [m_data=1]

construct A [m_data=2]

construct A [m_data=3]

construct A [m_data=4]

construct A [m_data=5]

construct A [m_data=6]

construct A [m_data=7]

construct A [m_data=8]

construct A [m_data=9]

Clearly the objects are initialised as they are instantiated. Although the array is a static array, the objects themselves are constructed dynamically. This allows us to construct the objects in the array far more efficiently simply by passing the data directly to the constructor. Aside from that, the only real difference is that the array is an array of pointers, rather than an array of objects. However, when we speak of an array of objects, we generally mean an array of pointers to objects.

Another advantage to using pointers to objects rather than actual objects is that it then makes it possible to store derivatives of the class in the array. For example:

struct A{};

struct B: public A {};

struct C: public A {};

A* a[10];

int i=0;

while (i<5){

a[i++]=new A;

}

while (i<8){

a[i++]=new B;

}

while (i<10){

a[i++]=new C;

}

Here we've created one array that contains three different types of object. However, since all the objects are a "kind of" A (since they all derive from A), this is perfectly acceptable and is something that simply cannot be done with an actual array of objects.

Answer 5

Object is the basic unit of object-oriented programming. Objects are identified by its unique name. An object represents a particular instance of a class. There can be more than one instance of a class. Each instance of a class can hold its own relevant data.An Object is a collection of data members and associated member functions also known as methods.