How do you inherit from class in c?

Answer 1

struct SClass{

int iNumber;

int (*fpgetValue)();

int (*fpsetValue)();

}Sc;

int m_Func(){

printf("\n\n Hello How are you doing,i called by function pointer");

getchar();

return 1;

}

int _tmain(int argc, _TCHAR* argv[])

{

Sc.fpgetValue=m_Func;

Sc.fpgetValue();

return 0;

}

Answer 2

In object-oriented programming, a class is a programming language construct that is used as a blueprint to create objects. This blueprint includes attributes and methods that the created objects all share.

Answer 3

You inherit from an existing class (the base class) by deriving a new class (the derived class) from the existing class. The derived class automatically inherits the public and protected members of its base class.

By way of an example, consider the following base class:

class Base{

private: int m_private;

protected: int m_protected;

public: int m_public;

};

Now consider the following derived classes which all inherit from Base:

class Derived_public : public Base{

};

class Derived_protected : protected Base{

};

class Derived_private : private Base{

};

For the sake of brevity, the three derived classes have no members other than those they inherit from Base.

All three inherit m_public and m_protected. m_private remains private to Base and is therefore inaccessible via the derived classes.

Derived_public is functionally equivalent to the following non-derived declaration:

class NonDerived_public{

public: int m_public;

protected: int m_protected;

};

However, Derived_protected is functionally equivalent to the following non-derived declaration:

class NonDerived_protected{

protected: int m_public;

protected: int m_protected;

};

Note that m_public has switched to protected access.

Finally, Derived_private is functionally equivalent to the following non-derived declaration:

class NonDerived_private{

private: int m_public;

private: int m_protected;

};

Again, note that m_public and m_protected have switched to private access.

It is also possible to change the access to individual members regardless of the inheritance:

class Derived : public Base{

private: int Base:m_public;

public: int Base:m_protected;

};

Note that the type of inheritance has no effect on the base class access specifiers. Only the derived class is modified according to the type of inheritance.

Derived classes can also inherit from more than one base class. Simply separate each inheritance with a comma:

class Base2{};

class MultiDerivative : public Base, public Base2{};

Multiple-inheritance is the same as single inheritance, other than that the derived class inherits the sum total of all public and protected members of its combined base classes.

Multi-level inheritance occurs whenever any derived class inherits from another derived class. The only real difference is that the most-derived class inherits the public and protected members of its most-immediate ancestor, including those it inherited from its base class and that still remain public or protected in that class.

Multi-level and multiple-inheritance can also be combined. However, sometimes this can introduce ambiguity when two or more base classes are themselves derived from a common base class. The most-derived class then inherits two or more instances of that common base class which is often undesirable. To avoid this problem, the common base class can be declared virtual, which then makes it a direct ancestor of the most-derived class, and this one instance is then shared amongst the base classes that are directly derived from it. For instance:

class Common{};

class Derived1 : virtual public Common{};

class Derived2 : public virtual Common{}

class Object : public Derived1, public Derived2{};

Note that the virtual keyword can be placed before or after the inheritance type, as shown in the example.

Without the virtual keyword in both Derived1 and Derived2, Object would inherit two separate instances of Common (one from Derived1, the other from Derived2). This would make it impossible to implicitly access any members of Common that were inherited by Object. You could use explicit access via Derived1::Common or Derived2::Common, but more often than not it is better to eliminate the duplicate instance altogether and have a single shared instance, thus removing the ambiguity. Ideally, the Common class should have few (if any) member variables; its existence should mainly be to provide a virtual (or pure-virtual) interface to all its derivatives.