In c++. when we want to define a pointer variable, the syntax is:
dataType* pointerVariable = &variableName;
which means the pointerVariable is of type dataType-pointer and stores the address of variableName in the memory. Now, when we want to define a function which accepts an argument by reference, the syntax is:
void functionName( dataType& argumentName );
And when we want to call that function, the syntax is:
functionaName( argumentName );
My question is, when we want to define a function which receives an argument by reference, which means a function that receives a pointer as an argument, why don't we use the same syntax as we used to define a pointer, like the following:
void functionName (dataType* argumentName);
And then, when we want to call that function, the syntax would be:
functionName(&argumentName);
Why new syntax has been drfined?
when we want to define a function which receives an argument by reference, which means a function that receives a pointer as an argument
There's your problem: you've confused semantics with implementation.
An argument that is a reference in C++ is an argument that is a reference. That's it as far as C++ is concerned. It's a reference argument and it behaves like the standard says a reference argument behaves.
The implementation of such a thing in the ABI used by the compiler may involve passing a pointer. But that's a matter of what the compiler does, not what happens in the model of C++ defined by the standard.
why don't we use the same syntax as we used to define a pointer
Because that's defining a function that takes a pointer.
A pointer and a reference aren't the same thing. Pointer variables can point to different objects at different times; reference variables cannot. Once a reference is bound to an object, it stays bound to that object, period.
Pointers can be NULL. References cannot, or at the very least, if you do a thing that would create a NULL reference, you have invoked UB, so there's no point in talking about the behavior of the program after that. And so forth.
However that reference variable gets implemented under the hood, those are the rules of C++ references and the compiler has to abide by them.