Insert Algorithmus



  • Hallo zusammen,

    ich habe gerade einen kleinen Algorithmus zum
    Einfügen eines Strings in einen anderen geschrieben.
    Nun meine Frage: kann man diesen Algorithmus noch
    irgendwie optimieren?

    char *pStr  = NULL;
    char cSrc[] = "Dies ist Test";
    char cIns[] = "ein ";
    int iIns    = 0;
    int iSLn    = 0;
    int iILn    = 0;
    
    iIns = 9;
    iSLn = strlen( cSrc );
    iILn = strlen( cIns ); 
    pStr = malloc( iSLn+1 );
    strcpy( pStr, cSrc );
    pStr = realloc( pStr, iSLn +iILn +1 );
    memcpy( &pStr[iIns] +iILn, &pStr[iIns], iSLn -iIns );
    memcpy( &pStr[iIns], cIns, iILn );
    pStr[iSLn +iILn] = '\0';
    

    Bye Peter.



  • Schaut eigentlich ganz ordentlich aus. Ein paar Leerzeilen der Übersicht halber würden vielleicht nicht schaden, aber das ist ja geschmacksache.

    Nur eins gefällt mir nicht. Und zwar die Kombination von & und []. Da kann man nämlich auch einfach nur + schreiben. Also anstatt &text[5] einfach text+5. Wobei man da wieder sagen könnte, dass es geschmacksache ist.



  • Warum realloc? malloc'e doch gleich die richtige Menge.



  • Hallo,
    es ist halt noch keine fertig Funktion sondern
    nur ein Testaufbau für den Algorithmus.

    @AJ,
    ich finde &..[] sieht schöner aus 🙂
    Aber wie du schon sagtest, ist geschmacksache.
    Von der Geschwindigkeit sollte
    beides das gleiche sein oder ?

    @Bashar,
    es geht ja darum: Ich habe im Programm einen
    String der mit malloc erstellt wurde.
    Nun möchte ich irgendwo anders im Programm in diesen
    String etwas einfügen. Folglich muss der ursprüngliche
    String größer werden. Da ich ja nicht wieß wieviel
    Zeichen in einfügen möchte, muss ich mit realloc arbeiten.

    So könnte dann die fertige Funktion aussehen:

    char *InsStr( char *pStr, char *pIns, int iIns )
    {
      int iStrLen;
      int iInsLen;
    
      if ( !pStr || !pIns )
        return NULL;
    
      iStrLen = strlen( pStr );
      iInsLen = strlen( pIns );
    
      pStr = realloc( pStr, iStrLen +iInsLen +1 );
      memcpy( &pStr[iIns] +iInsLen, &pStr[iIns], iStrLen -iIns );
      memcpy( &pStr[iIns], pIns, iInsLen );
      pStr[iStrLen +iInsLen] = '\0';
    
      return pStr;
    };
    

    Optimierungsvorschläge würden mich sehr interessieren.

    Bye Peter.



  • Gut.

    1. Bei deiner Abprüfung, ob einer der beiden char* 0 ist, würde ich nicht einfach NULL zurückgeben sondern, wie auch am Schluss, pStr.

    2. Da du das realloc in der Funktion verwendest und dabei einen Parameter änderst, musst du auf bestimmte Sachen aufpassen:

    pStr darf kein konstanter Zeiger sein, d. h. die Variablen, die du als pStr übergibst, müssen mit malloc() reserviert werden!

    Die Variable, die du als pStr übergibst, sollte auch den Rückgabewert deiner Funktion erhalten

    Eine andere Möglichkeit wäre, dass du bei pStr mit einem char ** arbeitest.

    3. Wenn du auf & [] bestehst, dann wärs vielleicht auch gut, es nicht zu mischen mit dem einfachen +, wie du es bei deinem ersten memcpy machst. Also anstatt & [] + so &[+] ;).



  • @AJ,

    ich habe auch schon überlegt der Funktion einen Puffer
    zu übergeben, in den das Ergebis kopiert wird. Dadurch
    wäre es egal ob der Ausgangsstring mit malloc erzeugt
    wurde oder nicht.
    Ohne diesen Puffer müsste es sonst in der
    Dokumentation der Funktion eindeutig beschrieben werden.
    Mit dem Mischen von & [] und + hast du natürlich Recht.

    Mich interessieren jedoch im Moment nur Optimierungsvorschläge.
    Wenn man den Code überhaupt noch optimieren kann.

    Bye Peter.



  • Jaein. Du könntest deine strlen() auslagern aus der Funktion und die Längen als Parameter übergeben. Ist hald die Frage ob, das auch wirklich Sinn macht.

    Dann ist da noch das mit dem realloc(). Wenn du gleich von vornherein bestimmst, dass der Zielstring genügend Speicher zur Verfügung haben muss, damit auch das eingefügte Platz hat, dann kannst du dir den realloc sparen.



  • @AJ,

    wow die Antworten kommen ja heute schnell.
    Liegt wohl daran, dass es Freitag ist 🙂

    Ja ich weiß, dass realloc die meiste Zeit braucht.
    Das Ziel war vor vornherein den String nur bei bedarf
    zu erweitern, daher kann ich in meinem Fall
    bei realloc nichts einsparen.

    Bye Peter.


Log in to reply