C++ references cannot be null.

If you are returning a reference to an object whose lifetime is not tied to the scope of the function call, like a data member, you can safely return a raw pointer (I would recommend a pointer to const).

std::string const* foo::bar() const {
    if (condition) {
        return &some_data_member;
    } else {
        return nullptr;
    }
}

If not, the best solution is to use a wrapper type like boost::optional (or std::optional in C++17). This not only allows you to return an optional object by value (which may be more performant), but is also self-documenting.

std::optional<std::string> foo::bar() const {
    if (condition) {
        return "hello, world";
    } else {
        return std::nullopt;
    }
}

Alternatively, you could return a pointer, which can be null. However, returning a raw pointer raises the question of who is responsible for deleting the dynamically allocated string. In this case, returning a std::unique_ptr would be the best option, as ownership is explicitly passed to the caller.

std::unique_ptr<std::string> foo::bar() const {
    if (condition) {
        return std::make_unique<std::string>("hello, world");
    } else {
        return nullptr;
    }
}

Or even simpler, you could return an empty string, if this is possible in your case. And honestly, this is my preferred approach (KISS).

std::string foo::bar() const {
    if (condition) {
        return "hello, world";
    } else {
        return "";
    }
}

This is undefined behavior. It might return the "correct" value; it might as well do something completely different, crash the program, or worse. The reason why it is undefined behavior is as follows:

char* test(){
    char A[100];
    scanf("%s", A);
    printf("A = %s \n", A);
    return(A);
}

Here you declare an array of 100 char on the stack. Later you return the address to that memory. However, it was on the stack, so that memory is invalid now. You then assign this invalid memory pointer to B:

char* B;
B = test();

So on this line:

printf("B = %s \n", B);  // why this return (null)?

You have undefined behavior.

Instead, try this:

char* test() {
    char* A = malloc(100);
    scanf("%s", A);
    printf("A = %s \n", A);
    return A;
}

In this function, the memory is allocated on the heap instead. This way, the pointer you return is valid (also note that you don't need any parentheses around the A in return A;). Don't forget to free the memory again, though. You do it by calling this at the end of your program:

free(B);

Note that for your code, your compiler will likely emit a warning. It might say something like:

returning address of local variable or temporary: A

Those warnings can help you find potential problems and debug your code. When a program isn't working, try resolving all the warning first.

It is not good idea to return "". Because, it is const char and you may try to dealloc it in where you get it from the function and this likely crashes your application.

So, I would return strdup(""), so you can free it safely.

StackOverflow has a good discussion about this exact topic in this Q&A. In the top rated question, kronoz notes:

Returning null is usually the best idea if you intend to indicate that no data is available.

An empty object implies data has been returned, whereas returning null clearly indicates that nothing has been returned.

Additionally, returning a null will result in a null exception if you attempt to access members in the object, which can be useful for highlighting buggy code - attempting to access a member of nothing makes no sense. Accessing members of an empty object will not fail meaning bugs can go undiscovered.

Personally, I like to return empty strings for functions that return strings to minimize the amount of error handling that needs to be put in place. However, you'll need to make sure that the group that your working with will follow the same convention - otherwise the benefits of this decision won't be achieved.

However, as the poster in the SO answer noted, nulls should probably be returned if an object is expected so that there is no doubt about whether data is being returned.

In the end, there's no single best way of doing things. Building a team consensus will ultimately drive your team's best practices.

Your line char *str = '\0'; actually DOES set str to (the equivalent of) NULL. This is because '\0' in C is an integer with value 0, which is a valid null pointer constant. It's extremely obfuscated though :-)

Making str (a pointer to) an empty string is done with str = ""; (or with str = "\0";, which will make str point to an array of two zero bytes).

Note: do not confuse your declaration with the statement in line 3 here

char *str;
/* ... allocate storage for str here ... */
*str = '\0'; /* Same as *str = 0; */

which does something entirely different: it sets the first character of the string that str points to to a zero byte, effectively making str point to the empty string.

Terminology nitpick: strings can't be set to NULL; a C string is an array of characters that has a NUL character somewhere. Without a NUL character, it's just an array of characters and must not be passed to functions expecting (pointers to) strings. Pointers, however, are the only objects in C that can be NULL. And don't confuse the NULL macro with the NUL character :-)

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.

You can throw an exception to indicate an error.

try {
    std::string response = receiveFromServer();
} catch(std::runtime_error & e) {
    std::cerr << e.what();
}

Then you would need a throw std::runtime_error("Error receive response") somewhere in receiveFromServer().

It is often considered good practice (though some might disagree) to create your own exception-classes that derive from std::runtime_error to enable clients to catch your errors specifically.

 if( mystruct == NULL )

mystruct is not a pointer, so you cannot compare it with NULL.

You have three options:

1. Add a status field to MyStruct to indicate whether the struct has been initialized correctly.
2. Allocate the struct on the heap and return it by pointer.
3. Pass the structure as a pointer argument and return a status code (thanks @Potatoswatter).

If the return type is int, you can't return a NULL. To show an error, you could instead return a special value like zero or -1, if you check for that value in any calling function. Lots of functions return nonnegative numbers on success, or -1 on error.

NULL cannot be stored in an int variable, unlike in SQL, for example. If you ignore the warning and return NULL anyway, then NULL will be casted to zero. The calling function won't be able to tell whether you returned NULL or zero.

If your function only needs to indicate success or failure, then it's common to return 1 for success, and zero for failure. Zero means "false" when treated as a boolean value (like in if statements), and non-zero means "true."