How do I call the parent function from a derived class using C++? For example, I have a class called parent
, and a class called child
which is derived from parent. Within
each class there is a print
function. In the definition of the child's print function I would like to make a call to the parents print function. How would I go about doing this?

- 2,652
- 6
- 25
- 38

- 12,300
- 11
- 37
- 45
-
2I wouldn't use the MSVC __super since it's platform specific. Although your code may not run on any other platform, I'd use the other suggestions since they do it as the language intended. – Teaser Oct 13 '10 at 23:39
-
Possible duplicate of [Can I call a base class's virtual function if I'm overriding it?](https://stackoverflow.com/questions/672373/can-i-call-a-base-classs-virtual-function-if-im-overriding-it) – Archmede Aug 09 '17 at 01:36
-
1The antipattern where derived classes are always *required* to call parent class functions is [Call super](https://en.wikipedia.org/wiki/Call_super) – Rufus Mar 05 '19 at 03:43
7 Answers
I'll take the risk of stating the obvious: You call the function, if it's defined in the base class it's automatically available in the derived class (unless it's private
).
If there is a function with the same signature in the derived class you can disambiguate it by adding the base class's name followed by two colons base_class::foo(...)
. You should note that unlike Java and C#, C++ does not have a keyword for "the base class" (super
or base
) since C++ supports multiple inheritance which may lead to ambiguity.
class left {
public:
void foo();
};
class right {
public:
void foo();
};
class bottom : public left, public right {
public:
void foo()
{
//base::foo();// ambiguous
left::foo();
right::foo();
// and when foo() is not called for 'this':
bottom b;
b.left::foo(); // calls b.foo() from 'left'
b.right::foo(); // call b.foo() from 'right'
}
};
Incidentally, you can't derive directly from the same class twice since there will be no way to refer to one of the base classes over the other.
class bottom : public left, public left { // Illegal
};
-
46
-
87@bluesm: in classic OOP it makes no much sense, but in generic programming `template
class C: public A, public B {};` can come to two types being the same for reasons depending on how your code is used (that makes A and B to be the same), may be two or three abstraction layer way from someone not aware of what you did. – Emilio Garavaglia Nov 18 '13 at 18:37 -
9I think it's useful to add, that this will call parent class method even if it is not implemented directly in the parent class, but **is** implemented in one of the parent classes in the inheritance chain. – Maxim Lavrov Dec 26 '14 at 10:30
-
-
@martinkunev, if the base class uses this then it works normally for regular methods and suppresses dynamic invocation for `virtual` methods. – Motti Jun 16 '15 at 14:35
-
5On a sidenote, it made me mad when i tried to put this in a cpp file. I had 'using namespace std'. 'left' is defined somewhere in that namespace. The example wouldn't compile - drove me crazy :) . Then I changed 'left' to 'Left'. Great example by the way. – Mathai Aug 27 '15 at 20:36
-
92
-
25+1 for stating `You should note that unlike Java and C#, C++ does not have a keyword for "the base class"`. – Niki Romagnoli Sep 16 '16 at 08:15
-
You can add `typedef left super;` in your class if you want, then you can refer to `super::foo();`. And since you cannot derive from the same class twice directly, you have to do it indirectly `struct left1 : left{}; struct left2 : left{}; class bottom : public left1, public left2 { ... };` but you are probably better off using composition rather than inheritance. – Eljay Sep 29 '17 at 12:39
-
2
-
The answer mentions you have to use :: if the base/derived signatures match, but do "overloads" between base/derived need it to? e.g., Base::foo(int), Derived::foo(Bar). I think if you say this->foo(3) in a derived method, you'll get an error. – sg_man Jul 01 '22 at 01:58
-
@sg_man `this->foo(3)` is equivalent to `foo(3)`. It will go to the derived method. I also think you may be confusing "overload" and "override", see https://www.scaler.com/topics/difference-between-function-overloading-and-overriding-in-cpp/. – Motti Jul 02 '22 at 20:24
-
Another convention similar to the typedef approach is `using Super =
`. For example: https://github.com/microsoft/react-native-windows/blob/e5e02d6046b1906cf154f2eacf8873fdd0afd4d1/vnext/Microsoft.ReactNative/GlyphViewManager.cpp#L30. – Liron Yahdav Dec 09 '22 at 22:20
Given a parent class named Parent
and a child class named Child
, you can do something like this:
class Parent {
public:
virtual void print(int x);
};
class Child : public Parent {
void print(int x) override;
};
void Parent::print(int x) {
// some default behavior
}
void Child::print(int x) {
// use Parent's print method; implicitly passes 'this' to Parent::print
Parent::print(x);
}
Note that Parent
is the class's actual name and not a keyword.

- 1,743
- 2
- 13
- 36

- 951,095
- 183
- 1,149
- 1,285
-
Of course, this would only be useful if the base call were interspersed with other logic, otherwise there'd be no point in overriding the function, so maybe it's a little _too_ to-the-point ;) – underscore_d Apr 11 '16 at 13:20
-
1@underscore_d actually, its useful even if the base call was not interspersed with other logic. Let's say the parent class pretty much does everything you want, but exposes a method foo() you don't want users of child to use - either because foo() is meaningless in child or external callers to child will screw up what child is doing. So child may use parent::foo() in certain situations but provide an implementation of foo so that they hide parent's foo() from being called. – iheanyi Apr 22 '16 at 18:56
-
@iheanyi Sounds interesting, but sorry, I'm not grasping it yet. Is `foo()` here analogous to `print()` or a separate function? And do you mean by using `private` inheritance to hide details inherited from the base, and providing `public` shadowing functions for things you _do_ want to expose? – underscore_d Apr 22 '16 at 19:02
-
@underscore_d Yes, `foo()` was analogous to `print()`. Let me go back to using `print()` as I think it would make more sense in this context. Let's say someone created a class that carried out some set of operations on a particular datatype, exposed some accessors, and had a `print(obj&)` method. I need a new class that works on `array-of-obj` but everything else is the same. Composition results in a lot of duplicated code. Inheritance minimizes that, in `print(array-of-obj&)` loop calling `print(obj&)`, but don't want clients to call `print(obj&)` because doesn't make sense for them to do so – iheanyi Apr 25 '16 at 15:34
-
@underscore_d This is predicated on the assumption that I can't refactor out the common parts of the original parent class or that doing so is incredibly costly. Private inheritance could work, but then you lose the public accessors which you were relying upon - and would thus, need to duplicate code. – iheanyi Apr 25 '16 at 15:37
If your base class is called Base
, and your function is called FooBar()
you can call it directly using Base::FooBar()
void Base::FooBar()
{
printf("in Base\n");
}
void ChildOfBase::FooBar()
{
Base::FooBar();
}

- 12,186
- 6
- 68
- 106

- 14,340
- 7
- 51
- 50
In MSVC there is a Microsoft specific keyword for that: __super
MSDN: Allows you to explicitly state that you are calling a base-class implementation for a function that you are overriding.
// deriv_super.cpp
// compile with: /c
struct B1 {
void mf(int) {}
};
struct B2 {
void mf(short) {}
void mf(char) {}
};
struct D : B1, B2 {
void mf(short) {
__super::mf(1); // Calls B1::mf(int)
__super::mf('s'); // Calls B2::mf(char)
}
};

- 4,216
- 1
- 23
- 31
-
5
-
26I won't try to justify usage of `__super`; I mentioned it here as an alternative suggestion. Developers should know their compiler and understand pros and cons of its capabilities. – Andrey Jan 30 '12 at 01:56
-
14I'd rather discourage anyone from using it, as it severely hinders portability of the code. – Erbureth Mar 13 '14 at 13:42
-
30I don't agree with Andrey: Developers should know the standard and should not need to bother with compiler features, if we consider writing software which is primarily compiler independent which I think is a good idea anyways because sooner or later in large projects multiple compilers are anyways used. – Gabriel Dec 11 '14 at 17:39
-
@ThomasEding I'd prefer neither, because C++ isn't Java, and it's not actually difficult to remember the name of the parent, plus it's _required_ if using MI. – underscore_d Apr 11 '16 at 13:21
-
11*"Developers should know their compiler"* this reasoning, and the inclusion of non standard features, is what led to IE6... – Déjà vu Aug 04 '16 at 10:50
-
1This is a really bad idea, always try to avoid compiler specific features, or is really needed, use them inside #defines where yoou can handle the standard and non standard way. – Patricio Rossi Jun 02 '17 at 02:30
-
1I'm going to go against the comments and vote in favour of `__super`. It's nice and simple, and for the 99.9% of code which is SANE and doesn't use multiple inheritance, there's no problem with it. Explicitly specifying the base class has led to multiple hard to diagnose horrible bugs in our codebase throughout the years, where people end up accidentally going straight from Level3->Level1 and skipping the Level2 class in the middle; __super prevents this. Also portable code, that's a good point, however not all code cares about being portable – Orion Edwards Aug 23 '17 at 04:39
-
1@OrionEdwards exactly for that code with only one inheritance `__super` doesn't add functionality, because you can name that class explicitly (or get a habit of doing `typedef Parent super` right after class declaration if you want to write `super`): it's main purpose is to dispatch the function call to one of the two super classes when a method could be in one or another (i.e., mixin scenario). Sacrificing standard compliance may be justified if you explicitly need that functionality, not for lazyness. – pqnet Mar 12 '18 at 11:20
-
@OrionEdwards, well, always call Level2 methods from Level3 and you'll be fine – Alexey Andronov May 16 '18 at 03:32
Call the parent method with the parent scope resolution operator.
Parent::method()
class Primate {
public:
void whatAmI(){
cout << "I am of Primate order";
}
};
class Human : public Primate{
public:
void whatAmI(){
cout << "I am of Human species";
}
void whatIsMyOrder(){
Primate::whatAmI(); // <-- SCOPE RESOLUTION OPERATOR
}
};

- 1,841
- 23
- 23
If access modifier of base class member function is protected OR public, you can do call member function of base class from derived class. Call to the base class non-virtual and virtual member function from derived member function can be made. Please refer the program.
#include<iostream>
using namespace std;
class Parent
{
protected:
virtual void fun(int i)
{
cout<<"Parent::fun functionality write here"<<endl;
}
void fun1(int i)
{
cout<<"Parent::fun1 functionality write here"<<endl;
}
void fun2()
{
cout<<"Parent::fun3 functionality write here"<<endl;
}
};
class Child:public Parent
{
public:
virtual void fun(int i)
{
cout<<"Child::fun partial functionality write here"<<endl;
Parent::fun(++i);
Parent::fun2();
}
void fun1(int i)
{
cout<<"Child::fun1 partial functionality write here"<<endl;
Parent::fun1(++i);
}
};
int main()
{
Child d1;
d1.fun(1);
d1.fun1(2);
return 0;
}
Output:
$ g++ base_function_call_from_derived.cpp
$ ./a.out
Child::fun partial functionality write here
Parent::fun functionality write here
Parent::fun3 functionality write here
Child::fun1 partial functionality write here
Parent::fun1 functionality write here

- 4,141
- 4
- 31
- 40
struct a{
int x;
struct son{
a* _parent;
void test(){
_parent->x=1; //success
}
}_son;
}_a;
int main(){
_a._son._parent=&_a;
_a._son.test();
}
Reference example.

- 441
- 3
- 10
-
4Could you please [edit] in an explanation of why/how this code answers the question? Code-only answers are discouraged, because they are not as easy to learn from as code with an explanation. Without an explanation it takes considerably more time and effort to understand what was being done, the changes made to the code, or if the code is useful. The explanation is important both for people attempting to learn from the answer and those evaluating the answer to see if it is valid, or worth up voting. – Makyen Feb 23 '15 at 05:30
-
4This answer is about nested classes while the question was about derived classes (even though the words 'parent' and 'child' are a bit missleading) and therefore doesn't answer the question at all. – Johannes Matokic Aug 05 '15 at 07:54