In addition to Will Dean's version, the following are common for whole buffer initialization:

Copychar s[10] = {'\0'};

or

Copychar s[10];
memset(s, '\0', sizeof(s));

or

Copychar s[10];
strncpy(s, "", sizeof(s));

It depends on what you mean by "empty". If you just want a zero-length string, then your example will work.

This will also work:

buffer[0] = '\0';

If you want to zero the entire contents of the string, you can do it this way:

memset(buffer,0,strlen(buffer));

but this will only work for zeroing up to the first NULL character.

If the string is a static array, you can use:

memset(buffer,0,sizeof(buffer));

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!

Define a buffer to hold the string contents:

#define BUFFER_SIZE 256 // or whatever size you need

char buffer[BUFFER_SIZE+1] = {0}; // +1 for string terminator, 
                                  // = {0} initializer zeroes out entire buffer

To assign a string to this buffer, use strcpy:

strcpy( buffer, "some string" );

To append a string to this buffer, use strcat:

strcat( buffer, "more string" );

EDIT

Now that you've edited your question, the problem is the line

tempo = "";

An array expression like tempo may not be the target of the = operator; you must use a library function like strcpy to assign string values. If you want to set tempo to an empty string, you can do any one of the following:

strcpy( tempo, "" );

or

tempo[0] = 0;

or

tempo[0] = '\0';

Short Answer:

const char *get_string() { return ""; }

or

char *get_string() { return const_cast<char *>(""); }

or

char *get_string() { return NULL; }

or

std::string get_string() { return std::string(); }

Detailed Answer:

Implicit conversion from string literal to char * is supported in C and C++98/C++03, but apparently not in C++11. The deprecation warning is just there to let you know that this should be addressed, particularly if you want to be able to migrate your code C++11.

The empty string literal ("") is not actually empty, it is a string containing a single null character (\0). When you use return "";, you are actually returning a pointer to the memory location of the const string literal so the function return type should be const char *.

If you really must return a non-const pointer to a string literal, you can use the const_cast operator to cast away the const.

A better practice would be to return NULL (or nullptr) for functions that are returning empty, non-const, C-style strings, but only if the calling code is checking for NULL pointers.

Note that C++ has its own string type (std::string), and an even better practice would be to use this rather than a C-style string when possible.

A couple of ways come to mind. Given that strings in C are usually terminated by an ASCII zero, the easiest would be to set the first byte to zero.

a[0] = '\0';

Now this doesn't erase all the characters in the string, but since the first character is now a termination character the string looks empty to your program.

If you want to erase all the characters in the string then you need to use a loop.

OR

Another way might be to use memset() to set the whole string to zeros.

memset(a, 0, strlen(a));

but this will only work for zeroing up to the first NULL character.

The easy way to do it would be like this:

if (msg[0])
    printf("message: %s", msg);

If, at some later date, msg is a pointer, you would first want to assure it's not a NULL pointer.

if (msg && msg[0])
    printf("message: %s", msg);

A test program to demonstrate:

#include <stdio.h>
#include <stdlib.h>

char *msg;

void test() {
    if (msg && msg[0])
        printf("string is %s\n", msg);
}

int main()
{
    msg = NULL;
    test();
    msg = calloc(10, 1);
    test();
    msg[0] = 'm';
    msg[1] = 'e';
    test();
    free(msg);
}

On my machine the output is:

string is me

That is perfectly well defined and the assertion passes. The c_str() function will always return a valid zero terminated C string.

One would normally use empty() to test for an empty string.

In C a string is an array of char and the end of the string is marked with a NUL character (aka '\0') which is nothing else than a byte of value 0.

If you want to have an empty string it is sufficient to do

temp[0] = '\0';

or

*temp = '\0';

which is the same.

If you defined something like

char temp[100];

you could also do

memset(temp, '\0', sizeof temp);

This will overwrite all characters, allowing you to fill in new data character by character without having to care about the terminating '\0'.

With dynamic allocation the answer will be different.

It depends a bit on how you want to assign a new value to temp, but in general it is not necessary to clear the old value before assigning a new value.

Arrays in C must have their size known when they are created, and the size cannot be changed after that.

So you must specify a size for all of your arrays.

You can omit the size number only if you provide an initializer, because the compiler can calculate the size from the initializer.

In your code you should select a size that is large enough to store what you expect. Also you used the wrong arguments to scanf. The code could be:

char first[100] = { 0 };    // avoid garbage in case input fails
scanf("%99s", first);

If you want to allow input of arbitrary size then you have to use dynamic allocation of space.

You're right: since calling strcmp() adds up the stack management and the memory jump to the actual strcmp instructions, you'll gain a few instructions by just checking the first byte of your string.

For your curiosity, you can check the strcmp() code here: http://sourceware.org/git/?p=glibc.git;a=blob;f=string/strcmp.c;h=bd53c05c6e21130b091bd75c3fc93872dd71fe4b;hb=HEAD

(I thought the code would be filled with #ifdef and obscure __GNUSOMETHING, but it's actually rather simple!)

The result of c_str() is only valid as long as the std::string object that produced that result is valid.

In your case, AsString() call produces a temporary std::string object which is then immediately destroyed. After that the result of that c_str() call no longer makes any sense. Trying to access the memory pointed by that pointer leads to undefined behavior.

Don't attempt to store the pointer returned by c_str(). If you need that string as a C-string for an extended period of time, allocate memory buffer for it yourself and copy the result of c_str() to that buffer.

Another (much better) idea would be not to rush the conversion to C-string. Return the result as std::string and call c_str() on it at the very last moment: when you reall really really need a C-string.

nul pad the string then wen reading out the result skip the nuls

char string[x*y+1]; // you had it too small

...

    fgets(string, x*y+1, stdin);              //immediatly as \n is still there)
    int num_read = strlen(string);
    if(num_read < x*y+1 )
       memset(string+num_read,'\0',x*y+1-num_read);
    if (string[num_read ] == '\n' )
        string[num_read ] = '\0';

...

    char message[x*y+1];  // was way too small!
    for(int j=0; j < x; j++){
        for(int i=0; i < y; i++){
            if(code[i][j])
              message[k] = code[i][j];
            k++;
        }
    } 
    message[k]='\0' 

You can also use empty

if(s.empty()) 

Use whatever you and your team find the most readable.

Other answers have suggested that a new string is created every time you use "". This is not true - due to string interning, it will be created either once per assembly or once per AppDomain (or possibly once for the whole process - not sure on that front). This difference is negligible - massively, massively insignificant.

Which you find more readable is a different matter, however. It's subjective and will vary from person to person - so I suggest you find out what most people on your team like, and all go with that for consistency. Personally I find "" easier to read.

The argument that "" and " " are easily mistaken for each other doesn't really wash with me. Unless you're using a proportional font (and I haven't worked with any developers who do) it's pretty easy to tell the difference.

It's implementation defined. §5.1.2.2.1 abridged:

• If the value of argc is greater than zero, the array members argv[0] through argv[argc-1] inclusive shall contain pointers to strings, which are given implementation-defined values by the host environment prior to program startup. The intent is to supply to the program information determined prior to program startup from elsewhere in the hosted environment. [...]

• If the value of argc is greater than zero, the string pointed to by argv[0] represents the program name; argv[0][0] shall be the null character if the program name is not available from the host environment. [...]

So if argc is greater than zero, it's quite the intention that argv[0] never be an empty string, but it could happen. (Note that with argc equal to n, argv[0] through argv[n - 1] are never null and always point to a string. The string itself may be empty, though. If n is zero, argv[0] is null.)

In practice, of course, you just need to make sure the platforms your targetting behave as needed.

Using fgets is pretty simple. As a feature, you can test to see it the input contains a newline. If not, there are pending characters.
scanf is possible using a scanset. %99[^\n] will scan up to 99 characters that are not a newline. %*c will consume the newline. If the only character is a newline then the scanset will fail and scanf will return 0. If more than 99 characters are entered, %*c will consume a character that is not a newline. fgets does not have that problem.

#include <stdio.h>

int main ( void) {
    char string[100] = "";
    int result = 0;

    printf ( "using fgets\nenter a blank line to stop\n");
    do {
        fgets ( string, sizeof string, stdin);
    } while ( string[0] != '\n');

    printf ( "using scanf\nenter a blank line to stop\n");
    do {
        result = scanf ( "%99[^\n]%*c", string);
    } while ( result == 1);

    return 0;
}

With ungetc, if scanf reads too many characters, the last character can be put back in the stream if it is not a newline.

    char last = 0;

    do {
        result = scanf ( "%99[^\n]%c", string, &last);
        if ( EOF == result) {
            fprintf ( stderr, "scanf EOF\n");
            return 0;
        }
        if ( '\n' != last) {
            ungetc ( last, stdin);
        }
    } while ( result == 2);

You can use c[i]= '\0' or simply c[i] = (char) 0.

The null/empty char is simply a value of zero, but can also be represented as a character with an escaped zero.