Segmentation Fehler nur in realease Konfiguration, wenn Zeichenkette in C

Question

unten sind die Funktion fast_integer_output Manipulieren der input_integer von der Basis 2 in output_base umwandelt.

my_str* fast_integer_output(bigint* input_integer, int output_base) 
{ 
    bigint** integer_to_binary_array = create_integer_to_binary_array(); 
    bigint* base = integer_to_binary_array[output_base]; 
    my_str* result = 0; 

    if(less_than(input_integer, base)) 
    { 
     char* p_char = (char*) get_memory(sizeof(char)); 
     p_char[0] = int_to_char(*(input_integer->number)); 

     result = create_string(p_char, 1); 
    } 
    else 
    { 
     long k = find_k(input_integer, base); 
     bigint* base_to_k = power(base, k); 

     bigint* quotient; 
     bigint* remainder; 

     divide(input_integer, base_to_k, &quotient, &remainder); 
     delete_bigint(&base_to_k); 

     my_str* low = fast_integer_output(remainder, output_base); 
     delete_bigint(&remainder); 

     my_str* high = fast_integer_output(quotient, output_base); 
     delete_bigint(&quotient); 

     result = concatenate(low, k - low->length, high); 

     delete_string(&low); 
     delete_string(&high); 
    } 

    release_integer_to_binary_array(integer_to_binary_array); 
    return result; 
} 

Hier sind Bigint und my_str structs und create_string Funktion (bitarray ist nur ein Zeiger auf long)

my_str* create_string(char* c_str, long length) 
{ 
    my_str* str = (my_str*) get_memory(sizeof(my_str)); 
    str->c_str = c_str; 
    str->length = length; 
} 

typedef struct 
{ 
    char* c_str; 
    long length; // logical 
} my_str; 

typedef struct 
{ 
    bitarray* number; 
    long  length; // logical 
    long  size; // physical 
} bigint; 

Und diese Funktionen sorgen für die Speicherverwaltung. Im Moment sind sie nur Funktionen umwickeln frei und malloc aber ich möchte eine Art von Speicher Pool implementieren, wenn es langsam in Betrieb sein wird.

void init_memory(void* memory, size_t size) 
{ 
    unsigned char* tmp = (unsigned char*) memory; 
    unsigned char c = 0; 

    while (size > 0) 
    { 
     *tmp = c; 
     tmp++; 
     size--; 
    } 
} 

void* get_memory(size_t size) 
{ 
    void* memory = malloc(size); 
    init_memory(memory, size); 
    return memory; 
} 

void release_memory(void** memory) 
{ 
    free(*memory); 
    *memory = 0; 
} 

Problem ist, dass alles auf Debug-Konfiguration fein läuft, aber auf Release-Konfiguration die Funktion fast_integer_output nicht auf der Linie:

result = concatenate(low, k - low->length, high); 

Das Problem ist, dass

my_str* low = fast_integer_output(remainder, output_base); 

die Rückkehr von diesem Stück Code

if(less_than(input_integer, base)) 
{ 
    char* p_char = (char*) get_memory(sizeof(char)); 
    p_char[0] = int_to_char(*(input_integer->number)); 

    result = create_string(p_char, 1); 
} 

gibt Müll zurück und es schlägt daher bei Segmentierungsfehler fehl.

hatte ich das gleiche Problem mit diesem Code:

QString buffer; // function parameter in real code 
instance_data_t data = {(unsigned char*) buffer.toStdString().c_str(), 0, 0, 0, 0, 0, 0, {0, 0}, {0, 0}, cur_state}; 

aber ich schaffte es, indem es in folgenden Wechsel zum Laufen zu bringen:

unsigned char c_buffer[1024]; 
memset(c_buffer, '\0', sizeof(c_buffer)); 
strcpy((char *) c_buffer, buffer.toStdString().c_str()); 

instance_data_t data = {c_buffer, 0, 0, 0, 0, 0, 0, {0, 0}, {0, 0}, cur_state}; 

Wichtiger Hinweis ist, dass ich keine andere Funktionen nutzen kann als schreiben, lesen, malloc und frei (also keine strcpy, oben code ist von test die ich nicht liefern werde)

Dies ist keine Hausaufgabe, es ist eine Aufgabe für einen Job (würde ich gerne bekommen).

Ich habe über 15-20 Fragen gesucht und gelesen, also werde ich sie nicht alle auflisten, aber das Problem ist, dass meistens, wenn die Frage nicht sehr spezifisch ist, der Segmentierungsfehler nicht wegen der Schnurmanipulation ist und wenn es ist, dann liegt es meistens daran, dass der Index nicht in der Nähe ist.

Answer 1

Ihre zugewiesene Zeichenfolge ist nicht null ('\ 0') beendet.

Ich würde es auf diese Weise tun:

char* p_char = (char*) get_memory(sizeof(char) * 2); 

    p_char[0] = int_to_char(*(input_integer->number)); 
    p_char[1] = 0; 

    result = create_string(p_char, 1); 

Wie EOF hingewiesen (siehe Kommentare), Die create_string Funktion als no return-Anweisung. So wird tatsächlich Müll zurückgegeben.

my_str* create_string(char* c_str, long length) 
{ 
    my_str* str = (my_str*) get_memory(sizeof(my_str)); 
    str->c_str = c_str; 
    str->length = length; 
    return str; 
}