Mit alloc Speicher reservieren

supertux

cHillb3rT schrieb:

Ist denn strcat ein Standardbefehl in der Programmierung oder muss ich da die Funktion nochmal selbst schreiben ?

siehe mein Post oben!

Herrmann

Dachtest du an folgendes?

int main(void)
{
  char bf1[128];
  char bf2[128];
  char *pRes;

  memset( bf1, 0, 128 );
  memset( bf2, 0, 128 );  
  gets( bf1 );
  gets( bf2 );

  pRes = malloc( strlen( bf1 ) +strlen( bf2 ) +1 );
  if ( pRes )
  {
    memset( pRes, 0, strlen( bf1 ) +strlen( bf2 ) +1 );
    strcat( pRes, bf1 );
    strcat( pRes, bf2 );
    printf( "%s\n", pRes );
  }; 

  return 0;
};

supertux

@Hermann: Du hast ein **free(pRes);**vergessen! Und benutze kein gets, fgets ist sicherer.

wozu denn das? memset( pRes, 0, strlen( bf1 ) +strlen( bf2 ) +1 );
ein *pRes=0; reicht schon

Herrmann

@supertux, OK hast recht Zu meiner Verteidigung..ich wollte ja nur herausfinden was cHillb3rT erreichen will und habe es daher ohne groß zu überlegen zusammengetippt

cHillb3rT

Ich bin gerade schon am herumtesten der neuen Version, aber dennoch hab ich mal eine Frage.

/* allocate memory for string: Im Klartext bedeutet dies, dass "str" den
    Wert der Anfangsadresse zugewiesen bekommt, ab der dann der reservierte
    Speicherbereich - char für char - durchgegangen wird. Wenn nicht genügend
    Speicher vorhanden ist, dann wird NULL zurückgegeben. */
    if ((str = (char *) malloc(10)) == NULL)

Stimmt das was in die Blockkommentare geschrieben habe... ?

cHillb3rT

So ich hab jetzt eine Version geschrieben, die die zwei Zeichenketten zu einer macht.

#include <stdio.h>
#include <alloc.h>

void strcat(char *s, char *t);

int main(int argc, char* argv[])
{
  char *input1, *input2;
  input1 = (char*)malloc(256);
  input2 = (char*)malloc(256);
  gets(input1);
  gets(input2);
  strcat(input1, input2);
  printf("%s", input1);
  return 0;
  }

/* Zuerst zeigen "s" und "t" auf den Anfang der Zeichenketten. In der ersten while-
Schleife wird "s" bis zum Null-Byte ('\0') am Ende der einen Zeichenkette weitergeführt.
Die Bedingung in while *s ist erfüllt, bis das Null-Byte gefunden wird.
Die zweite while-Schleife fügt die Zeichenkette bei "t" an die Zeichenkette bei s an.
Diese Anweisung weist auf das Zeichen, auf das "t" zeigt, an das Byte zu, das "s" zeigt führt
dann beide Zeiger weiter und macht das so lange, wie "t" nicht auf ein Nullzeichen zeigt. */

void strcat(char *s, char *t)
{

  while (*s)
    s++;
  while(*s++ = *t++)
  ;
}

Das Programm funktioniert... kann man noch was besser machen ? - Ich sehe schon z. B., dass man gets gegen fgets austauschen kann, aber ansonsten sieht alles sehr solide aus !

Herrmann

@cHillb3rT, am Ende musst du natürlich den reservierten Speicher wieder freigeben...siehe Kommentar von supertux zu meinem Code Du wirst auch noch ein Problem haben, wenn beide Zeichenketten zusammen mehr als 256-Zeichen lang sind. Ansonsten siehts ja OK aus.

cHillb3rT

hmmm.... das Problem mit der Ausgabe besteht also immer noch !

Demnach müsste ich also eine Variable haben, die das Ergebnis speichert und dementsprechend Speicherplatz besitzt, dass es keinen Speicheradressenfehler gibt oder ?

supertux

hey, un du musst stdlib.h includieren, alloc.h , malloc.h & Co. sind nicht portabel! Bitte, lese die Antworten, die wir dir geben. Benutze kein gets sondern fegts! Und wieso benutzt du nicht strcat der ANSI Bib?

supertux

Hier ein Beispiel:

#include <stdio.h> /* für printf, scanf, fgets */
#include <stdlib.h> /* für malloc, free, atoi */
#include <string.h> /* für strcat, strlen */

int main(int argc, char** argv)
{

    char* input1, *input2;
    char* result;
    int len;

    if (argc==1)
    {
        fprintf(stderr, "usage: %s number of characters you want to input\n", argv[0]);
        return 1;
    }

    len = atoi(argv[1]);

    if(len <1)
    {
        fprintf(stderr, "Insert a number greater than 0\n");
        return 1;
    }

    if(NULL==(input1 = malloc(len+1)))
    {
        fprintf(stderr, "Out of memor\n");
        return 1;
    }

    if(NULL==(input2 = malloc(len+1)))
    {
        fprintf(stderr, "Out of memor\n");
        free(input1);
        return 1;
    }

    printf("Insert somthing (only %d chars): ", len);
    fgets(input1, len, stdin);
    printf("Insert somthing (only %d chars): ", len);
    fgets(input2, len, stdin);

    /* löchen von \n */
    input1[strlen(input1)-1]=0;
    input2[strlen(input2)-1]=0;

    if(NULL==(result = malloc(strlen(input1)+strlen(input2)+1)))
    {
        fprintf(stderr, "Out of memor\n");
        free(input1);
        free(input2);
        return 1;
    }

    /* result muss 0-terminierend sein */
    *result=0;

    strcat(result,input1);
    strcat(result,input2);

    printf("You've inserted: %s\n", result);

    free(input1);
    free(input2);
    free(result);

    return 0;

}