String Padding in C

Question

Ich schrieb diese Funktion, die angeblich ist StringPadRight zu tun ( "Hallo", 10, "0"). -> "Hello00000"

char *StringPadRight(char *string, int padded_len, char *pad) {
    int len = (int) strlen(string);
    if (len >= padded_len) {
        return string;
    }
    int i;
    for (i = 0; i < padded_len - len; i++) {
        strcat(string, pad);
    }
    return string;
}

Es funktioniert hat, aber einige seltsame Nebenwirkungen ... einige der anderen Variablen erhalten geändert. Wie kann ich dieses Problem beheben?

Answer 1

Es könnte hilfreich sein, zu wissen, dass printf Polsterung für Dich tut, -10s als Format String Pad% den Eingang rechts in einem Feld 10 Zeichen lang

printf("|%-10s|", "Hello");

Wille Ausgang

|Hello     |

In diesem Fall ist das -. Symbol bedeutet „links ausrichten“, die 10 bedeutet „Zehn Zeichen im Feld“ und die s bedeutet, dass Sie eine Zeichenfolge ausrichten

Printf Stil Formatierung in vielen Sprachen verfügbar ist und viele Referenzen im Web hat. Hier ist eine von vielen Seiten die Formatierungs Flags zu erklären. Wie üblich auch Wikipedias printf ist von Hilfe (meist eine Geschichtsstunde, wie printf weit ausgebreitet hat) .

Answer 2

‚C‘ gibt es alternative (komplexere) Verwendung von [S] printf, die keine malloc benötigt () oder Vorformatierung, wenn individuelle Polsterung gewünscht wird.

Der Trick ist, verwenden ‚*‘ Länge Bezeich (min und max) für% s, sowie eine Zeichenfolge gefüllt mit Füllzeichen auf die maximale Potenzial Länge.

int targetStrLen = 10;           // Target output length  
const char *myString="Monkey";   // String for output 
const char *padding="#####################################################";

int padLen = targetStrLen - strlen(myString); // Calc Padding length
if(padLen < 0) padLen = 0;    // Avoid negative length

printf("[%*.*s%s]", padLen, padLen, padding, myString);  // LEFT Padding 
printf("[%s%*.*s]", myString, padLen, padLen, padding);  // RIGHT Padding 

Das "% *. * S" kann, bevor platziert wird oder nach "% s", je nach Wunsch nach LINKS oder RECHTS Polsterung.

  

[####Monkey] <-- Left padded, "%*.*s%s"
    [Monkey####] <-- Right padded, "%s%*.*s"

Ich fand, dass die PHP printf ( hier ) die Fähigkeit unterstützt eine benutzerdefinierte geben Füllzeichen, mit dem Apostroph ( '), gefolgt von Ihren benutzerdefinierten Füllzeichen , innerhalb der% s-Formats.
      printf("[%'#10s]\n", $s); // use the custom padding character '#'
produziert:
      [####monkey]

Answer 3

Sie müssen sicherstellen, dass die Eingabezeichenfolge genug Platz, um alle Füllzeichen zu halten hat. Versuchen Sie folgendes:

char hello[11] = "Hello";
StringPadRight(hello, 10, "0");

Beachten Sie, dass ich 11 Bytes für die hello Zeichenfolge zugewiesen am Ende für den Null-Terminator zu berücksichtigen.

Answer 4

Das Argument Sie bestanden „Hallo“ auf dem konstanten Datenbereich. Es sei denn, Sie genügend Speicherplatz auf char * Zeichenfolge zugewiesen haben, ist es Überholkupplung zu anderen Variablen.

char buffer[1024];
memset(buffer, 0, sizeof(buffer));
strncpy(buffer, "Hello", sizeof(buffer));
StringPadRight(buffer, 10, "0");

Edit:. Korrigierte vom Stapel zu konstantem Datenbereich

Answer 5

Oh ok, macht Sinn. Also habe ich diese:

    char foo[10] = "hello";
    char padded[16];
    strcpy(padded, foo);
    printf("%s", StringPadRight(padded, 15, " "));

Danke!

Answer 6

#include <iostream>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

using namespace std;

int main() {
    // your code goes here
    int pi_length=11; //Total length 
    char *str1;
    const char *padding="0000000000000000000000000000000000000000";
    const char *myString="Monkey";

    int padLen = pi_length - strlen(myString); //length of padding to apply

    if(padLen < 0) padLen = 0;   

    str1= (char *)malloc(100*sizeof(char));

    sprintf(str1,"%*.*s%s", padLen, padLen, padding, myString);

    printf("%s --> %d \n",str1,strlen(str1));

    return 0;
}

Answer 7

Die Funktion selbst sieht für mich in Ordnung. Das Problem könnte sein, dass Sie nicht genug Platz für Ihren String Pad, das viele Zeichen auf sie zuweist. Sie könnten dieses Problem in Zukunft vermeiden, indem ein size_of_string Argument an die Funktion übergeben und stellen Sie sicher, dass Sie die Zeichenfolge nicht Pad tun, wenn die Länge etwa ist die Größe größer sein als.

Answer 8

Eine Sache, die in der Funktion definitiv falsch ist, die die ursprüngliche Frage in diesem Thread bildet, die ich nicht, dass jemand erwähnt gesehen habe, ist, dass es wörtlichen zusätzliche Zeichen an das Ende der Zeichenfolge verketten, die als übergeben wurden Parameter. Dies führt zu unvorhersehbaren Ergebnissen führen. Im Beispiel Aufruf der Funktion wird die Stringliteral „Hallo“ fest codiert wird in das Programm, so vermutlich auf das Ende verketten es gefährlich Code schreibt über wird. Wenn Sie eine Zeichenfolge zurück, die größer ist als das Original, dann müssen Sie sicherstellen, dass Sie es dynamisch zuweisen und sie dann in dem anrufenden Code löschen, wenn Sie fertig sind.

Answer 9

#include <stdio.h>
#include <string.h>

int main(void) {
    char buf[BUFSIZ] = { 0 };
    char str[] = "Hello";
    char fill = '#';
    int width = 20; /* or whatever you need but less than BUFSIZ ;) */

    printf("%s%s\n", (char*)memset(buf, fill, width - strlen(str)), str);

    return 0;
}

Ausgabe:

$ gcc -Wall -ansi -pedantic padding.c
$ ./a.out 
###############Hello

Answer 10

#include<stdio.h>
#include <string.h>


void padLeft(int length, char pad, char* inStr,char* outStr) {
    int minLength = length * sizeof(char);
    if (minLength < sizeof(outStr)) {
        return;
    }

    int padLen = length - strlen(inStr);
    padLen = padLen < 0 ? 0 : padLen;

    memset(outStr, 0, sizeof(outStr));
    memset(outStr, pad,padLen);
    memcpy(outStr+padLen, inStr, minLength - padLen);
}