§13.1, где Стандарт обсуждает объявления, которые не могут быть перегружены, -

Объявления параметров, которые отличаются только наличием или отсутствием const и / или volatile, эквивалентны. То есть, сопзИ и летучий типа спецификаторы для каждого типа параметра игнорируются [...]

Только const и volatile спецификаторы типа на самом внешнем уровне спецификации типа параметра игнорируются таким образом; Спецификаторы типа const и volatile, скрытые в спецификации типа параметра, имеют большое значение и могут использоваться для различения объявлений перегруженных функций. [...]

при определении, какая функция объявляется, определяется или вызывается. В частности, для любого типа T «указатель на T», «указатель на const T» и «указатель на изменчивый T» считаются различными типами параметров, как и «ссылка на T», «ссылка на const T» и «ссылка на летучий Т.»

РЕДАКТИРОВАТЬ 2:

Поскольку сообщение по существу совпадает с ссылочным сообщением , за исключением того, что перегруженные функции теперь являются функциями-членами класса, я пытаюсь проиллюстрировать дополнительный аспект, который может быть полезен для иллюстрации концепции перегрузки, которая отличается от перегрузки на основе «constness» аргументов (либо в области видимости класса, либо в пространстве имен). Однако ОП хотел знать, как различать две перегрузки.

Способ их успешной перегрузки зависит от квалификации cv подразумеваемого первого параметра в случае вызовов функций-членов, как показано. Функция-член const может быть вызвана только в том случае, если выражение объекта, используемое для вызова перегруженной функции-члена, также является const. Когда неконстантное выражение объекта используется для вызова перегруженного вызова функции-члена, предпочтительна неконстантная версия, поскольку она является точным соответствием (вызов перегруженной функции-члена const потребует квалификации cv первого подразумеваемого аргумента)

#include <iostream> 
using std::cout; 

class Test { 
        public: 
        Test(){}
        int foo (const int) const; 
        int foo (int ); 
}; 

int main () 
{ 
        Test obj;
        Test const objc;  // const object
        obj.foo(3);       // calls non const overload, object expression obj is non const
        objc.foo(3);      // calls const overload, object expression objc is const
} 

int Test::foo(int a) 
{ 
   a++; 
   return a; 
} 

int Test::foo (const int a) const
{ 
   return a; 
} 

Вы не можете перегружать, основываясь только на константности не указателя, не ссылочного типа.

Подумайте, например, если бы вы были компилятором. Столкнулся с линией:

 cout <<obj.foo(3);

какую функцию вы бы назвали?

Когда вы передаете по значению, значение копируется в любом случае. Значение const в аргументе относится только к определению функции.

В ответ на другой вопрос , объясняет, два foos не отличается , потому что они имеют эквивалентные определения параметров.