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

Я знаю, что мы не можем перегружать конструкторы, как показано ниже (Единственное отличие заключается в списке инициализации):

myClass(const INT& oInt,const STRING& oStr):I(oInt),STR(oStr){

cout << "my Class Object Created with I : " << I << " STR : " << STR << endl;
}

myClass(const INT& oInt,const STRING& oStr){
I=oInt;
STR=oStr;
cout << "my Class Object Created with I : " << I << " STR : " << STR << endl;
}

Но предположим, что я хочу перегрузить свой конструктор так:

myClass(const INT& oInt,const STRING& oStr):I(oInt),STR(oStr);
myClass(const INT oInt,const STRING oStr);

то есть на основе другого типа параметра one as reference type другой as normal type

Я имею в виду мой старый вопрос:
Перегрузка функции-члена класса

Это может быть достигнуто?

Мой код:

#include <iostream>
#include <string>

using namespace std;

class INT{
int i;
public:

INT(int i=0):i(i){
cout << "INT Class Object Created with i : " << i << endl;
}

~INT()
{
cout << "INT Class Object Destructed with i :" << i << endl;
}

INT(const INT& I){
i=I.i;
cout << "INT Class Copy Constructor called for i : "<< i << endl;
}

INT& operator= (const INT& I){

i=I.i;
cout << "INT Assignment operator called for i : "<< i << endl;
return *this;
}

friend ostream& operator << (ostream& os,const INT& I){
os << I.i ;
return os;
}

};class STRING{

string str;

public:
STRING(string str=""):str(str){

cout << "STRING Class Object Created with str : " << str << endl;
}
~STRING()
{
cout << "STRING Class Object Destructed with str :" << str << endl;
}STRING(const STRING& S){
str=S.str;
cout << "STRING Class Copy Constructor called for str : "<< str << endl;
}

STRING& operator= (const STRING& S){

str=S.str;
cout << "STRING Assignment operator called for str : "<< str << endl;
return *this;
}

friend ostream& operator << (ostream& os,const STRING& S){
os << S.str ;
return os;
}

};class myClass{

INT I;
STRING STR;
public:

myClass(const INT& oInt,const STRING& oStr):I(oInt),STR(oStr){

cout << "my Class Object Created with I : " << I << " STR : " << STR << endl;
}

myClass(const INT oInt,const STRING oStr){
I=oInt;
STR=oStr;
cout << "my Class Object Created with I : " << I << " STR : " << STR << endl;
}~myClass()
{

cout << "my Class Object Destructed with I : " << I << " STR : " << STR << endl;

}

};
int main()
{

INT iObj(5);
STRING strObj("Alina Peterson");cout << "\n\n======================================================\n\n" << endl;

myClass myObj(iObj,strObj);

cout << "\n\n======================================================\n\n" << endl;

return 0;
}

Я получаю ошибку:

$ g++ -g -Wall CPP.cpp -o CPP
CPP.cpp: In function ‘int main()’:
CPP.cpp:116:32: error: call of overloaded ‘myClass(INT&, STRING&)’ is ambiguous
myClass myObj(iObj,strObj);
^
CPP.cpp:116:32: note: candidates are:
CPP.cpp:86:1: note: myClass::myClass(INT, STRING)
myClass(const INT oInt,const STRING oStr){
^
CPP.cpp:81:1: note: myClass::myClass(const INT&, const STRING&)
myClass(const INT& oInt,const STRING& oStr):I(oInt),STR(oStr){
^

Как я приведу свой конструктор, чтобы он мог различать две версии моего перегруженного конструктора?