Wypełnienie strun w C

Napisałem tę funkcję, która ma wykonywać StringPadRight ("Hello", 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;
}

Działa, ale ma dziwne skutki uboczne ... niektóre inne zmienne ulegają zmianie. Jak mogę to naprawić?

Warto wiedzieć, że printf wykonuje za Ciebie dopełnienie, używając% -10s jako ciągu formatu, który wypełni dane wejściowe bezpośrednio w polu o długości 10 znaków

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

wyjdzie

|Hello     |

W tym przypadku symbol - oznacza „Wyrównaj do lewej”, 10 oznacza „Dziesięć znaków w polu”, a s oznacza, że ​​wyrównujesz ciąg.

Formatowanie w stylu Printf jest dostępne w wielu językach i ma wiele odniesień w Internecie. Oto jedna z wielu stron wyjaśniających flagi formatowania. Jak zwykle pomocna jest również strona printf WikiPedia (głównie lekcja historii o tym, jak szeroko rozpowszechnił się printf).

Dla „C” istnieje alternatywne (bardziej złożone) użycie [s] printf, które nie wymaga żadnego malloc () ani wstępnego formatowania, gdy pożądane jest niestandardowe wypełnienie.

Sztuczka polega na użyciu specyfikatorów długości „*” (min i max) dla% s oraz łańcucha wypełnionego znakiem dopełniającym do maksymalnej potencjalnej długości.

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 

"% *. * S" można umieścić przed lub po "% s", w zależności od potrzeby dopełnienia LEWEGO lub PRAWEGO.

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

Zauważyłem, że PHP printf ( tutaj ) obsługuje możliwość nadania niestandardowego znaku wypełnienia, używając pojedynczego cudzysłowu ('), po którym następuje niestandardowy znak wypełnienia , w formacie% s.
printf("[%'#10s]\n", $s); // use the custom padding character '#'
produkuje:
[####monkey]

Musisz upewnić się, że ciąg wejściowy ma wystarczająco dużo miejsca, aby pomieścić wszystkie znaki wypełniające. Spróbuj tego:

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

Zauważ, że przydzieliłem 11 bajtów na hellołańcuch, aby uwzględnić terminator zerowy na końcu.

Argument, który przekazałeś „Hello”, znajduje się w obszarze danych stałych. O ile nie przydzieliłeś wystarczającej ilości pamięci do char * string, przepełnia on inne zmienne.

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

Edycja: Poprawiono ze stosu do stałego obszaru danych.

No dobra, ma sens. Więc zrobiłem to:

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

Dzięki!

#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;
}

#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;
}

Wynik:

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

Sama funkcja wygląda dla mnie dobrze. Problem może polegać na tym, że nie przydzielasz wystarczającej ilości miejsca, aby twój ciąg mógł wypełnić tak wiele znaków. Możesz uniknąć tego problemu w przyszłości, przekazując size_of_stringargument do funkcji i upewnij się, że nie dopełniasz łańcucha, gdy długość ma być większa niż rozmiar.

Jedną rzeczą, która jest zdecydowanie błędna w funkcji, która tworzy oryginalne pytanie w tym wątku, o którym nikt nie wspominał, jest konkatenacja dodatkowych znaków na końcu literału ciągu, który został przekazany jako parametr. To da nieprzewidywalne rezultaty. W przykładowym wywołaniu funkcji ciąg znaków „Hello” zostanie na stałe zakodowany w programie, więc przypuszczalnie konkatenacja na jego końcu spowoduje niebezpieczny zapis w kodzie. Jeśli chcesz zwrócić ciąg, który jest większy niż oryginał, musisz upewnić się, że przydzielasz go dynamicznie, a po zakończeniu usuń go z kodu wywołującego.

#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);
}