How sizeof differentiate between an array and a pointer

This is like asking: "How the compiler differentiate between an array declaration and a pointer one?"
You know, the compiler parses the source code and it is able to differentiate the different arguments of sizeof operator because the programming language is not ambiguous.

Quote:

Since the array name points to the first element of the array, i.e array name is also a kind of pointer.

Yes and no. Yes, in many ways, you can use the array name like a pointer. But no, that doesn't make it a pointer. There are a couple of important distinctions:

1. You cannot assign another array to an array name .
2. As a consequence, you cannot allocate an array on the heap.
3. Likewise, you cannot delete or free an array name.

An array is a type that shares some of the behaviour of a pointer, in the same way that int variables and pointers share some of their arithmetic operators. They're still quite different types.


P.S.:
A pointer is like a street sign in a city. An array is like a street. While the street may start at the position of the street sign, that doesn't make the sign a street. And if you query the size of the sign, or the size of the street, you will notice a difference! ;)

You can treat this problem this way: builtin C array types have an automatic type conversion operator that can convert the array into a typed pointer (that points to the array).
An expression that evaluates to an array or array reference (for example the identifier of the array itself is one such expression) behaves as an array by default but this array expression can be automatically casted into a typed pointer by the compiler if the context requires that. In case of sizeof the compiler isn't forced to do the cast.

A conversion operator in action:

class MyArray
{
public:
    MyArray()
    {
        memset(&m_Arr, 0, sizeof(m_Arr));
    }

    // conversion operators
    operator int*()
    {
        return m_Arr;
    }
    operator const int*() const
    {
        return m_Arr;
    }

    int& operator[](int index)
    {
        return m_Arr[5];
    }
    const int& operator[](int index) const
    {
        return m_Arr[5];
    }
private:
    int m_Arr[5];
};

void dojob(const int* p)
{
    printf("%p", p);
}

void funcc()
{
    MyArray arr;
    // the MyArray class can be casted to int* and const int*
    // by the compiler thanks to the conversion operators
    int* p = arr;
    dojob(arr);
}

EDIT: A type conversion operator (that I have written into my class) can convert any type to any other type but the conversion is used by the compiler implicitly only if it is necessary or if you ask the compiler to do so with a static_cast.

A pointer and an array are 2 different types, just there is a builtin auto conversion from array to typed pointer. Its also an accident that you can use both types as an array with the subscript (indexing []) operator. There is also pointer to array conversion in some cases:

void tfunc(int arr[5])
{
}

void Test()
{
    int *p = NULL;
    tfunc(p);
}

This is not a real conversion because when you declare a function parameter as an array, then it is only a pointer and the size I specified doesn't really matter. sizeof(arr) would be the same as the size of a pointer.