How the data and functions are organized in object oriented programming?

Answer 1

We can think of an object is being an aggregate of one or more data types, where each member is allocated memory according to its type, and one member immediately follows another in the order it is declared. The total size of an object is therefore equal to the sum of its member types. However, some types need to be padded so they begin on a word boundary (such as a 4 byte boundary), so there may be unused padding bytes between certain members. This is why we strive to declare data members in descending order of size to minimise wastage.

Public and protected members are also inherited from base classes and are therefore part of the derived object, however private members are also part of the object (they're simply not accessible via the derived object), thus the total size will include those members as well. As such, each member can be accessed indirectly as an offset from the start address of the object. However, the compiler takes care of this for us, we can simply access object members through their given name (so long as access is permitted of course).

While every object of a class has its own discrete set of member data, as determined by the class definition, there is only one instance of each member function. The compiler knows which instance of the object to operate upon because a hidden "this" pointer is passed to every non-static member function. Thus the member functions are not considered part of the object per se, they are part of the class.

Every class that declares or inherits a virtual function also has its own virtual table, which is an aggregate of its base class virtual tables plus any of its own virtual function declarations. Each entry in the table points to the most-derived override for each virtual function. This ensures that the most-derived override is invoked even when the function is called against one of the object's base classes.

As such, there is only one implementation of every function in a program, and each has a unique address regardless of how many objects that function is a member of. This is similar to the way in which static member functions are shared by all instances of a class, the only difference being that static member functions do not receive a "this" pointer. By the same token, there is only one instance of each static data member which is shared by all objects of the class but is not associated with any specific object of the class. All static data members are allocated in the program's data segment whereas non-static member data is allocated on the stack unless the object is allocated dynamically upon the heap.

Answer 2

Data and functions are placed into some classes (an instance of a class is an object of that class). The classes are the abstraction (of some things) and with inheritance being a part of "being a class", to encapsulate the data and functions operated on those data.

Answer 3

Object Oriented Programming has everything to do with a programming language.

Programming Languages are classified into:

1.Object Oriented Programming

2.Process Oriented Programming

In Object Oriented Programming, more stress is given to data rather than Algorithm of the program giving the programmer his fre will to do anything without violating few rules of programming(like grammatical errors).

Object Oriented Programming breaks the program into small objects so as to make it easily changable & to prevent free flow of data and also to create a logical insulation between the program and outside world.

Answer 4

It depends on the language implementation. However, in C++, a member function is not actually part of the class in which it is declared. That aspect only exists within the source code and is simply a programming aid to help us reason our code more easily. Once compiled, the object-oriented nature of the source code is completely stripped away; it has served its purpose and is no longer required.

To understand this better, consider the following code:

class foo {

int attribute;

public:

void method (int data) {attribute = data; }

};

int main () {

foo f; f.method (42); }

When we compile this code, the machine code generated by the compiler is essentially the same as the machine code generated by the following C code:

struct foo {

int attribute;

// ...

};

void method (int data, foo* this) { this->attribute = data; }

int main () {

foo f;

method (42, &f);

return 0;

}

With a suitable compiler, it is possible to generate pure C code from C++ code. Indeed, that's precisely how the very first C++ compiler worked!

From this we can see that the actual object's layout is no different to a struct in C. That is, all non-static member data is stored in the class (struct) instances while static member data is allocated in static memory. Hence static member data is accessible without instantiating objects of the class.

Non-static member functions and static member functions are simply treated as if they were global functions. The only difference between the two is that a non-static member function has an implicit "this" pointer while static member functions do not.

Note that we do not need to test the "this" pointer for NULL before dereferencing it; it has to be non-NULL because the original C++ code guaranteed it; the member function was invoked against an object of the class, therefore the object must exist. Although it is possible to create a NULL reference in C++, if we follow best coding practices (using resource handles and references instead of "naked" pointer) then it becomes next to impossible to create one by accident. As such we can eliminate a lot of the runtime checks that prevail in pure C code.

Virtual functions are also treated as if they were really global functions. The only difference is that additional memory is set aside for the class virtual table (vtable), which simply holds pointers to the class functions. Each class that declares or overrides a class with virtual functions has its own virtual table with its own set of function pointers. When we implicitly invoke a virtual function, the compiler generates code to perform a runtime lookup of the most-derived class vtable in the hierarchy, because its vtable will refer to the most-derived override. This incurs a small performance overhead but the lookup is much quicker than using runtime type information. Conversely, if we explicitly invoke a virtual method against a particular class within the hierarchy, then the compiler simply looks at the virtual table specific to that class and statically binds to the appropriate function at compile time. As such, a derived class can override its base class and (optionally) explicitly invoke its base class method at no additional cost.

Answer 5

How are data and functions organised in an object oriented program?

Answer 6

Data and methods in OOP are organized in classes.

Answer 7

dfdafdaf