C Differentiating Between Pointer to Char and Pointer to Char Array

Differentiating between the two is entirely your responsibility.

In the case of a pointer to a single char, you could be careful enough to have it as a char * const which will not allow you to increment the pointer or otherwise change what it points to and walk off to somewhere and undefined behavior, but you will still be able to modify the value it points to.

C is very low level and very "bare bone" language. You have to be very responsible when you work with pointers. Naturally this applies to char * as well as to any other "array" - if not null terminated, you should by all means pass the length of the array and use that for a guide.

Arrays passed to functions as arguments are implicitly converted to pointers to their first elements. So there is no difference whether a pointer points to a single scalar object or to the first object of an array. Pointers do not possess such piece of information.

As for standard string functions that have names started from str then it is supposed that they deal with strings that is with character arrays that contain data terminated by zero.

So in fact you can make a mistake and pass to a string function a pointer that points to a single character object. But in this case the program behaviour will be undefined.

On the other hand if to follow exactly the title of your post then a pointer to character array differs from a pointer to a single character.

For example consider the following declarations

char *pc = "Hello";
char ( *ps )[6] = &"Hello";

As you can see pc and ps where ps is a pointer to a character array have different declarations.:) And you can also see the difference if you dereference the pointers. For example

printf( "%zu\n", sizeof( *pc ) );
printf( "%zu\n", sizeof( *ps ) );

You're basically correct. It's no different to a pointer to a single character. The function does not know the difference between you passing a single character (bad) and passing a string (good). If you happened to pass the address of a single char (that had non-zero value) then the behavior of this function would be undefined. In this type of scenario C is not typesafe.

Pointer to array of unknown bound of characters should be used instead. This is what everyone should do but AFAIK no-one does:

void str_cpy(char (*s)[], char (*t)[]) {{

    char *str_cpy[2] = { *s, *t }, *s = *str_cpy, *t = str_cpy[1];

{
    void str_cpy(char (*s)[], char (*t)[]);


    while ( (*s = *t) != '\0') s++, t++;
}
}}

Note that incrementing pointer to array of unknown size is forbidden and also not desired here so change in function code is required (as I did above).

You can then pass strings like this:

char str[20], str1[20];

strcpy(&str, &str1);

This way you can diagnose accidentally pass pointer to a single character:

char singleChar = 'H';

strcpy(&singleChar, &singleChar); //warning

Life example.

The problem is, however, that using a char * variable is the most practical way to access each individual char from any "array of char" because you can directly increment such a variable to make it refer the next array element (which you can't do using a pointer to array - incrementing such will make it refer to the next array in memory instead of the next char of the array pointed). Additionally the syntax of using a pointer to array is more complex.