Q:

Why does this code to modify a string not work?

With c-style strings, how do you assign a char to a memory address that a character pointer points to?  For example, in the example below, I want to change num to "123456", so I tried to set p to the digit where '0' is located and I try to overwrite it with '4'. Thanks.
#include <stdio.h>
#include <stdlib.h>

int main()
{
    char* num = (char*)malloc(100);
    char* p = num;

    num = "123056";

    p = p+3;    //set pointer to where '4' should be
    p = '4';

    printf("%s\n", num );

    return 0;
}

A:

First of all, when you do:
num = "123056";

You are not copying the string "123056" to the area of heap allocated by malloc().  In C, assigning a char * pointer a string literal value is equivalent to setting it as a constant - i.e. identical to:
char str[] = "123056";

So, what you've just accomplished there is you've abandoned your sole reference to the 100-byte heap area allocated by malloc(), which is why your subsequent code doesn't print the correct value;  'p' still points to the area of heap allocated by malloc() (since num pointed to it at the time of assignment), but num no longer does.
I assume that you actually intended to do was to copy the string "123056" into that heap area. Here's how to do that:
strcpy(num, "123056");

Although, this is better practice for a variety of reasons:
strncpy(num, "123056", 100 - 1);  /* leave room for \0 (null) terminator */

If you had just done:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int     main(void) {
        char    *num = malloc(100);
        char    *p = num;

        strncpy(num, "123056", 100 - 1);

        p = p + 3;
        *p = '4';

        printf("%s\n", num);

       return 0;
} 

You would have gotten the correct result:
123456

You can contract this operation:
p = p + 3;
*p = '4';

... and avoid iterating the pointer, by deferencing as follows:
*(p + 3) = '4';

A few other notes:

Although common stylistic practice, casting the return value of malloc() to (char *) is unnecessary.  Conversion and alignment of the void * type is guaranteed by the C language.
ALWAYS check the return value of malloc().  It will be NULL if the heap allocation failed (i.e. you're out of memory), and at that point your program should exit.
Depending on the implementation, the area of memory allocated by malloc() may contain stale garbage in certain situations.  It is always a good idea to zero it out after allocation:
memset(num, 0, 100);

Never forget to free() your heap!  In this case, the program will exit and the OS will clean up your garbage, but if you don't get into the habit, you will have memory leaks in no time.

So, here's the "best practice" version:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int     main(void) {
        char    *num, *p;

        /*
         * Don't take 1-byte chars for granted - good habit to get into.
         */

        num = malloc(sizeof(char) * 100);

        if(num == NULL)
                exit(1);

        memset(num, 0, sizeof(char) * 100);

        p = num;

        strncpy(num, "123056", 100 - 1);

        *(p + 3) = '4';

        printf("%s\n", num);

        free(num);

        return 0;
}

A:

That code won't work, simply because the line:
num = "123056";

changes num to point away from the allocated memory (and p remains pointing to the that memory so they're no longer the same location) to what is most likely read-only memory. You are not permitted to change the memory belonging to string literals, it's undefined behaviour.
You need the following:
#include <stdio.h>
#include <stdlib.h>
int main (void) {
    char *num = malloc (100); // do not cast malloc return value.
    char *p = num;

    strcpy (num, "123056");   // populate existing block with string.

    p = p + 3;                // set pointer to where '0' is.
    *p = '4';                 // and change it to '4'.

    printf ("%s\n", num );    // output it.

    return 0;
}

