Check if the first character is '\0'. You should also probably check if your pointer is NULL.

char *c = "";
if ((c != NULL) && (c[0] == '\0')) {
   printf("c is empty\n");
}

You could put both of those checks in a function to make it convenient and easy to reuse.

Edit: In the if statement can be read like this, "If c is not zero and the first character of character array 'c' is not '\0' or zero, then...".

The && simply combines the two conditions. It is basically like saying this:

if (c != NULL) { /* AND (or &&) */
    if (c[0] == '\0') {
        printf("c is empty\n");
    }
}

You may want to get a good C programming book if that is not clear to you. I could recommend a book called "The C Programming Language".

The shortest version equivalent to the above would be:

if (c && !c[0]) {
  printf("c is empty\n");
}

Since C-style strings are always terminated with the null character (\0), you can check whether the string is empty by writing

do {
   ...
} while (url[0] != '\0');

Alternatively, you could use the strcmp function, which is overkill but might be easier to read:

do {
   ...
} while (strcmp(url, ""));

Note that strcmp returns a nonzero value if the strings are different and 0 if they're the same, so this loop continues to loop until the string is empty.

Hope this helps!

Given this code:

char text[50];
if(strlen(text) == 0) {}

Followed by a question about this code:

 memset(text, 0, sizeof(text));
 if(strlen(text) == 0) {}

I smell confusion. Specifically, in this case:

char text[50];
if(strlen(text) == 0) {}

... the contents of text[] will be uninitialized and undefined. Thus, strlen(text) will return an undefined result.

The easiest/fastest way to ensure that a C string is initialized to the empty string is to simply set the first byte to 0.

char text[50];
text[0] = 0;

From then, both strlen(text) and the very-fast-but-not-as-straightforward (text[0] == 0) tests will both detect the empty string.

head->data will not equal NULL, it's not a pointer. If you're doing C strings, then checking for the \0 character will suffice. There isn't anything more to it.

In C, strings, by definition, are terminated by '\0', the NUL character. So all (valid) strings have a '\0' in them, at the end.

To find the position of the '\0', simply use strlen():

const char * const end = str + strlen(str);

It's odd that you are using "unsigned char" if you are dealing with normal, printable strings. If you mean that you have a memory block with bytes it in and you want to find the first 0x00 byte, then you'll need a pointer to the start of the memory and the size of the memory area, in bytes. Then, you'd use memchr():

// Where strSize is the number of bytes that str points to.
const unsigned char * const end = memchr(str, 0, strSize);

This if statement

if(_char_array[0] != '\0') {...}

checks whether a character array contains a non-empty string.

In fact there are compared two integers: the first character of the array _char_array promoted to the type int and the integer character constant '\0' that has the type int.

The statement can be rewritten also like

if( _char_array[0] ) {...}

or

if( *_char_array ) {...}

This if statement

if(_char_array != '\0') {...}

does not make a sense because any array occupies a memory extent. So converted to a pointer to its first element it can not be a null pointer.

That is in this statement there are compared a pointer to the first element of the array due to the implicit conversion of the array to a pointer to its first element and a null pointer constant.

If _char_array is initially declared as a pointer then the above if statement checks whether the pointer is not a null pointer.

The statement can be rewritten like

if( _char_array ) {...}