Не понятное в языке программирования С - C (СИ)

unsigned char str_array[50][50];
 
str_array[0][50] = "First string";
str_array[1][50] = "Second string";
.
.
.
str_array[49][50] = "Final string";

#define ARRAY_LENGTH 50
 
unsigned char str_array[ARRAY_LENGTH];

#include <iostream.h>
 
// Коллекция моих функция реалзованых на С(Си)
 
// substr, str_replace, assembler_test, sp_to_dash, 
// hash_generation, str_all_to_upper, str_all_to_lower
 
#define MY_FUNCTIONS_BUFFER_LENGTH 4096
 
unsigned char *substr(const char *str_subject, unsigned int str_start, unsigned int str_length);
 
unsigned char *substr(const char *str_subject, unsigned int str_start, unsigned int str_length) {
 
    // Эта функция работала почти корректно. Ничего не правильного не заметил.
 
    unsigned char substr_buffer[MY_FUNCTIONS_BUFFER_LENGTH];
                                               
    unsigned int substr_cnt = 0;
 
    while( substr_cnt < str_length ) {
        
        substr_buffer[substr_cnt] = *(str_subject + str_start + substr_cnt);
    
        substr_cnt ++;      
    }
 
    substr_buffer[substr_cnt] = '\0';
 
    return substr_buffer;
}
 
#define MY_FUNCTIONS_BUFFER_LENGTH 4096
 
unsigned char *str_replace(const char *str_search, const char *str_replace, const char *str_subject);
 
unsigned char *str_replace(const char *str_search, const char *str_replace, const char *str_subject) {
 
    // str_replace function testing begin.
 
    unsigned char *str_replace_buffer;
 
    str_replace_buffer = str_replace("{LABEL}", "/Replace/", "{LABEL}");
 
    printf("ex.: %s\n", str_replace_buffer);
 
    str_replace_buffer = str_replace("{LABEL}", "/Replace/", "{LABEL}{LABEL}{LABEL}");
 
    printf("ex.: %s\n", str_replace_buffer);
*
    str_replace_buffer = str_replace("{LABEL}", "/Replace/", "{LAB");
 
    printf("ex.: %s\n", str_replace_buffer);
 
    str_replace_buffer = str_replace("{LABEL}", "/Replace/", "test {LABEL}");
 
    printf("ex.: %s\n", str_replace_buffer);
 
    // str_replace function testing end.
 
    // функция str_replace почему так до конца достаточно и не работает. Работает с очень ошибками.
    // Надо ее доработать. Так же в эту функцию и в функцию substr, и во все остальные функции доработать
    // контроль ошибок когда один из параметров либо все либо выборочно не заданы либо ещё что то не так
    // так же доработать все свои остальные функции. Все.
 
    unsigned char returned_buffer[MY_FUNCTIONS_BUFFER_LENGTH];
 
    unsigned str_search_c = 0, 
        str_replace_c = 0, 
        str_subject_c = 0, 
     str_replace_buffer_c = 0,
         str_search_l = strlen(str_search),
        str_replace_l = strlen(str_replace),
        str_subject_l = strlen(str_subject);
 
    while( str_subject_c < str_subject_l ) {        
        
        while( * (str_subject + str_subject_c) == * (str_search + str_search_c) ) {
                                       
            str_subject_c ++;
    
            str_search_c ++;
        }
 
        if( str_search_c == str_search_l ) {
 
            while( str_replace_c < str_replace_l ) {
 
                        returned_buffer[str_replace_buffer_c] = * (str_replace + str_replace_c);
 
                str_replace_buffer_c ++;
 
                str_replace_c ++;
 
            }
        
            str_replace_c = 0;
        
        }
 
        if( str_search_c > 0 && str_search_c < str_search_l ) {
 
            str_subject_c -= str_search_c;
        }
 
        str_search_c = 0;
 
        // Важно, эта строка стояла в самом верху цикла и сильно влияла на работу модуля.
 
        returned_buffer[str_replace_buffer_c] = * (str_subject + str_subject_c);
 
        str_replace_buffer_c ++;
 
        str_subject_c ++;
    }
    
    returned_buffer[str_replace_buffer_c] = '\0';
 
    return returned_buffer;
}
 
void assembler_test(void);
 
void assembler_test(void) {
    
    unsigned char c = '0';
 
    printf("%x\n", &c);
 
    __asm__ __volatile__ (
        "movl $0x0018ff57, %eax\n"
        "addb $0x0f, (%eax)\n"
    );
 
    // ^ комманды call, out не работают, почему то
 
    printf("%c", c);
}
 
void sp_to_dash(char *str);
 
void sp_to_dash(char *str) {
 
    while(*str) {
        
        if(*str == ' ') {
            
            printf("-");
 
        } else {
 
            printf("%c", *str);
        }
 
        str++;
    }   
}
 
void hash_generation(unsigned char output_hash[], unsigned short int output_hash_length);
 
void hash_generation(unsigned char output_hash[], unsigned short int output_hash_length) {
 
    srand(time(0));
 
    unsigned short int current_hash_index, current_hash_segment_type, current_hash_segment;
 
    int current_hash_index = 0;
 
    while( current_hash_index < output_hash_length ) {
        
        current_hash_segment_type = 0 + rand() & 3 ;
 
        switch( current_hash_segment_type ) {
        
            case 0: 
                current_hash_segment = (char)(48 + rand() % 9);
                break;
 
            case 1:         
                current_hash_segment = (char)(65 + rand() % 25);
                break;
 
            default:
                current_hash_segment = (char)(97 + rand() % 25);            
        }       
 
        output_hash[current_hash_index] = current_hash_segment;
    
        current_hash_index ++;      
    }
}
 
void str_all_to_upper(char str[]);
 
void str_all_to_upper(char str[]) {
 
        int char_index;
    
    for( char_index = 0; char_index < strlen(str); char_index ++ ) {
        
        str[char_index] = toupper(str[char_index]);
    }
}
 
void str_all_to_lower(char str[]);
 
void str_all_to_lower(char str[]) {
 
        int char_index;
    
    for( char_index = 0; char_index < strlen(str); char_index ++ ) {
        
        str[char_index] = tolower(str[char_index]);
    }
}
 
unsigned long int ansi_c_89_strlen(unsigned char *subject);
 
unsigned long int ansi_c_89_strlen(unsigned char *subject) {
 
    unsigned long int char_index = 0;
 
    while( subject[char_index] != '\0' ) char_index ++;
    
    return char_index;
}