Understanding Overload Resolution

Overloading on const-ness of *this

Can I overload member functions based on the const-ness of the object they're called on?

Illustration representing computer hardware

Yes, you can overload member functions based on whether the object they're called on is const or not. This is a powerful feature in C++ that allows you to have different behaviors for const and non-const objects.

When you declare a member function as const, it promises not to modify the object's state. You can then overload the function with a non-const version, which is allowed to modify the object.

Here's an example:

#include <iostream>

class MyClass {
  void Print() const {
    std::cout << "Const version\n";

  void Print() {
    std::cout << "Non-const version\n";

int main() {
  MyClass obj;
  const MyClass cobj;

  obj.Print();// calls non-const version
  cobj.Print();// calls const version
Non-const version
Const version

In this code, the MyClass has two overloads of the Print function: one const, and one non-const.

When we call Print on a non-const object obj, it calls the non-const version. When we call Print on a const object cobj, it calls the const version.

This allows you to have different implementations for const and non-const objects. The const version might only read the object's state, while the non-const version might modify it.

This overloading based on const-ness is resolved at compile time, based on the static type of the object. It's a different mechanism from virtual functions, which are resolved at runtime based on the dynamic type of the object.

Answers to questions are automatically generated and may not have been reviewed.

Free, Unlimited Access

Professional C++

Comprehensive course covering advanced concepts, and how to use them on large-scale projects.

Screenshot from Warhammer: Total War
Screenshot from Tomb Raider
Screenshot from Jedi: Fallen Order
Contact|Privacy Policy|Terms of Use
Copyright © 2024 - All Rights Reserved