Thread: Problem with memory allocation

Im having problem with the memory allocation.

.H

Code:

#ifndef DSTRING_H
#define DSTRING_H
#include <stdio.h>

typedef char* DString;

/* Returnerar en sträng som innehåller samma text som textsträngen 'str'. 
  Den returnerade strängen är dynamiskt allokerad (dvs, på heapen) */
DString dstring_initialize(const char* str);

/* Slår ihop originalsträngen med source */
int dstring_concatenate(DString* destination, DString source);

/* Förkortar *destination så att den innehåller högst truncatedLength tecken 
  Om 'truncatedLength' är längre än strängens längd händer inget */
void dstring_truncate(DString* destination, unsigned int truncatedLength);

/* Skriver strängen till en textfil. 
   Textfilen förväntas redan vara öppnad och fortsätter vara öppnad efter anropet */
void dstring_print(DString stringToPrint, FILE* textfile);

/* Frigör minnet för en dynamisk sträng och sätter strängen (*stringToDelete) till NULL */
void dstring_delete(DString* stringToDelete);

#endif

I think the problem is in both concatanate and truncate functions.

Code:

#include "dstring.h"
#include <string.h>
#include <stdlib.h>
#include <assert.h>


DString dstring_initialize(const char* str)
{
    assert(str != NULL); // Precondition

    DString sameStr;

    sameStr = (char*) malloc(sizeof(char) * (strlen(str)+1)); // Allokerar en dynamisk sträng

    sameStr = strcpy(sameStr, str); // Kopierar innehållet i "str" till "sameStr"

    assert(*sameStr == *str); // Kollar om strängarna har samma innehåll

    return sameStr;
}

int dstring_concatenate(DString* destination, DString source)
{
    assert(*destination != NULL); // Avreferar och man kommer åt innehållet
    assert(destination != NULL); // Kollar så den inte är tom
    assert(source != NULL); // kollar så att den innehåller en sträng

    DString oneSent;

    oneSent = (char*) realloc(*destination, sizeof(char)*(strlen(*destination)+1) + (strlen(source)+1)); // Omallokerar för två strängar

    oneSent = strcat(*destination, source); // Sätter ihop *destination och source

    assert(oneSent == *destination && source); // Kollar om oneSent har samma innehåll som *destination och source

    return 1;
}

void dstring_truncate(DString* destination, unsigned int truncatedLength)
{
    assert(destination != NULL);
    assert(*destination != NULL);

    *destination = realloc(*destination, sizeof(char) * (truncatedLength + 1)); // Omallokerar för en sträng
    *destination = "Department";

    assert(strlen(*destination) == truncatedLength); //kollar om längden är 10
}

void dstring_print(DString str, FILE* textfile)
{
    assert(textfile != NULL);

    fprintf(textfile, "%s", str); // textfile är en stdout som printar ut str

}

void dstring_delete(DString* stringToDelete)
{
    assert(stringToDelete != NULL); // Kollar om det finns något att frigöra

    free(*stringToDelete); // Frigör minnet

    *stringToDelete = NULL; // Tömmer innehållet i strängen

    assert(*stringToDelete == NULL);
}

Test program

Code:

#include <assert.h>
#include <string.h>

#include "dstring.h"

/* Detta program testar funktionaliteten för ADTn DString */
int main(void)
{
    DString str1, str2;
    str1 = dstring_initialize("Department of ");
    str2 = dstring_initialize("Redundancy ");
    dstring_concatenate(&str1, str2); // Slår ihop str1 och str2 och lägger resultatet i str1. Str1 innehåller nu "Department of Redundancy"

    /* Om någon av dessa misslyckas så är det något fel på er implementation
       Använd debuggern för att ta reda på vad */

    assert(str1 != NULL);
    assert(str2 != NULL);
    assert(strlen(str2) == 11); 
    assert(strlen(str1) == 25); // Den sammanslagna strängen ska ha längden 25

    /* Följande ska skriva ut "Department of Redundancy Department" på skärmen
       stdout är en textfil som representerar konsollfönstret */

    dstring_print(str1, stdout);    // Skriver ut "Department of Redundancy" 
    dstring_truncate(&str1, 10);    // Förkortar str1 så att den bara innehåller de 10 första tecknen i strängen, dvs "Department"
    dstring_print(str1, stdout);    // Skriver ut "Department"

    /* Frigör det dynamiskt allokerade minnet för strängarna */
    dstring_delete(&str1);
    dstring_delete(&str2);

    /* Se till att strängarna blivit nollställda */
    assert(str1 == NULL);
    assert(str2 == NULL);
    return 0;
}

Im having problem with the memory allocation.

What exactly is the problem?

One thing I see is that you appear to be trying to compare strings with the operator==, this will not work you need to use something like strcmp().

Also I don't recommend hiding a pointer behind a typedef.

Jim

realloc may move the memory block to a new location, whose address is returned by the realloc function.

So you should be using the returned pointer from realloc when calling strcat.