strncpy is (essentially always) the wrong choice. In this specific case, it'll work, but only pretty much by accident -- since you're copying the end of a string, it'll work just like strcpy. That of course, leads to the fact that strcpy will work too, but more easily.

If you want to handle a more general case, there's a rather surprising (but highly effective) choice: sprintf can do exactly what you want:

sprintf(d, "%s", c+20);

sprintf (unlike strncpy or strcpy) also works for the most general case -- let's assume you wanted to copy just do I to d, but have d come out as a properly NUL-terminated string:

sprintf(d, "%*s", 4, c+13);

Here, the 4 is the length of the section to copy, and c+13 is a pointer to the beginning of the part to copy.

The header <string.h> contains function strlen that returns the length of a passed string. The function is declared like

    size_t strlen(const char *s);

Strictly speaking the last character of a string is its terminating zero character '\0'. But it seems by the last n characters of a string you mean n characters before the terminating zero.

To be able to get a pointer to the last n characters of a string the string should have at least n characters.

You could write a function the following way. If the passed string contains less than n characters then the function returns a pointer to the string itself.

char * last_n( const char *s, size_t n )
{
    size_t length = strlen( s );

    return ( char * )( length < n ? s : s + length - n );
} 

Here is a demonstrative program.

#include <stdio.h>
#include <string.h>
#include <ctype.h>

char * last_n( const char *s, size_t n )
{
    size_t length = strlen( s );

    return ( char * )( length < n ? s : s + length - n );
} 

int main(void) 
{
    char s[] = "Hello world!";
    
    char *p = last_n( s, 6 );
    
    puts( p );
    
    for ( char *current = p; *current != '\0'; ++current )
    {
        *current = toupper( ( unsigned char )*current );
        putchar( *current );
    }
    putchar( '\n' );
    
    return 0;
}

The program output is

world!
WORLD!

If you need to obtain the index where the last n characters of a string start you can write for example

char *p = last_n( s, n );
size_t pos = p - s;

Or just

size_t pos = last_n( s, n ) - s;

Just perform if ( strcmp(str1+strlen(str1)-4, str2+strlen(str2)-4) == 0 ) {}.

Make sure both strings are at least 4 characters long.

Is find_last_of what you need?

size_type find_last_of( const basic_string& str, size_type pos = npos ) const;

Finds the last character equal to one of characters in the given character sequence. Search finishes at pos, i.e. only the substring [0, pos] is considered in the search. If npos is passed as pos whole string will be searched.

When the string is null-terminated you can use strlen to get the lenght of the string:

char s[5];
size_t len, offset;
char dest[] = "abcdef.ghi";

len = strlen(dest);
memset( s, '\0', sizeof(char)*5);
offset = len-4;
strncpy( s, &dest[offset], 4 );

If this is not the case you can loop over the string as an array and look for your dot.

Afterwards you can use this index to calculate your correct offset. But be careful for that solution. If one string does not hate a dt and last free character you can cause an access violation.

Well, color1 and color2 are two bytes long - you have no room for the \0 terminator. When you look at one of them as a string, you get more characters that you wished for. If you look at them as two characters, you'll get the right result.

You should define them as 3 characters long and put the \0 at the end.

Yes you can. But in that case must not have to use the character array as a string, i.e, you must not apply any string operation on it (as it is not \0 terminated and will invoke undefined behavior).

To copy that array, you can use a loop or standard library function memcpy or memmove.