First of all, note that the warning is generated by your compiler (or static analyzer, or linter), not by your debugger, as you initially wrote.

The warning is telling you that your program possibly might dereference a null pointer. The reason for this warning is that you perform a malloc() and then use the result (the pointer) without checking for NULL values. In this specific code example, malloc() will most likely just return the requested block of memory. On any desktop computer or laptop, there's generally no reason why it would fail to allocate 12 bytes. That's why your application just runs fine and exits successfully. However, if this would be part of a larger application and/or run on a memory-limited system such as an embedded system, malloc() could fail and return NULL. Note that malloc() does not only fail if there is not enough memory available, it could also fail if there is no large enough consecutive block of memory available, due to fragmentation.

According to the C standard, dereferencing a NULL pointer is undefined behavior, meaning that anything could happen. On modern computers it would likely get your application killed (which could lead to data loss or corruption, depending on what the application does). On older computers or embedded systems the problem might be undetected and your application would read from or (worse) write to the address NULL (which is most likely 0, but even that isn't guaranteed by the C standard). This could lead to data corruption, crashes or other unexpected behavior at an arbitrary time after this happened.

Note that the compiler/analyzer/linter doesn't know anything about your application or the platform you will be running it on, and it doesn't make any assumptions about it. It just warns you about this possible problem. It's up to you to determine if this specific warning is relevant for your situation and how to deal with it.

Generally speaking, there are three things you can do about it:

1. If you know for sure that malloc() would never fail (for example, in such a toy example that you would only run on a modern computer with gigabytes of memory) or if you don't care about the results (because the application will be killed by your OS and you don't mind), then there's no need for this warning. Just disable it in your compiler, or ignore the warning message.

2. If you don't expect malloc() to fail, but do want to be informed when it happens, the quick-and-dirty solution is to add assert(v != NULL); after the malloc. Note that this will also exit your application when it happens, but in a slightly more controlled way, and you'll get an error message stating where the problem occurred. I would recommend this for simple hobby projects, where you do not want to spend much time on error handling and corner cases but just want to have some fun programming :-)

3. When there is a realistic change that malloc() would fail and you want a well-defined behavior of your application, you should definitely add code to handle that situation (check for NULL values). If this is the case, you would generally have to do more than just add an if-statement. You would have to think about how the application can continue to work or gracefully shutdown without requiring more memory allocations. And on an embedded system, you would also have to think about things such as memory fragmentation.

The easiest fix for the example code in question is add the NULL-check. This would make the warning go away, and (assuming malloc() would not fail) your program would run still the same.

int main(void) {
    uint32_t *v = malloc(3 * sizeof(uint32_t));
    if (v != NULL) {
        v[0] = 12;
        v[1] = 59; 
        v[2] = 83; 
        twice_three(v); 
        free(v); 
    }
    return 0; 
}

Yes, that warning is there because malloc could return NULL if allocation failed.

It's actually a warning from SAL annotations applied to the library headers, not Visual Studio itself. You should always check malloc return value for NULL and handle it, because malloc could return NULL if it fails. My usual method is:

   space = malloc(SIZE);
   if(NULL == space)
   {
       // If desired, output an error message to `stderr` here  
       goto cleanup;
   }

   use(space);

cleanup:
   free(space);
   space = NULL;

Coverity is giving you a warning because you are in fact doing a NULL check:

if (a_ptr && a_ptr->ptr) {

Here, a_ptr is evaluated in a boolean context. It evaluates to true if a_ptr is not NULL.

This warning thrown by Coverity if you dereference a pointer and then later on do a NULL check on it. This means one of two things:

• The pointer could in fact be NULL and any dereference prior to that NULL check could result in a NULL pointer dereference, so you need to either do the NULL check sooner or don't deereference at that point.
• The NULL check is unnecessary because the pointer can't be NULL, so the NULL check should be removed.

In this particular case, you're explicitly setting a_ptr to the address of a variable, so it can't possibly be NULL at that point. If you don't set it again before the above if statement, that means that the NULL check is unnecessary and should be removed.

You aren't aborting early from the function if dest is nullptr. That's why you get a compiler warning. You'd surely crash if strCat(nullptr, "foo") was invoked. Although as others have said, actual strcat may not check either pointer parameter for null.

More pro-tips:

• You don't need to invoke strLen. Especially not for src. You can exit the copy loop as soon as src points to a null char.

• strcat is expected to return dest

Quite simply we can do this:

char* strCat(char* dest, const char* src) {
        char* result = dest;

        // validate parameters
        if ((dest == nullptr) || (src == nullptr)) {
            return result;
        }

        // advance dest to the existing null char
        while (*dest != '\0') {
            dest++;
        }

        // copy loop
        while (*src != '\0') {
            *dest = *src;
            dest++;
            src++;
        }

        // make dest null terminated
        *dest = '\0';
        return result;
}