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ć?
printf
nie wydaje się zawierać żadnych wskazówek dotyczących takich funkcji.)printf
powinien zachowywać się prawie tak samo, jeśli nie identycznie, jest to C, a nie C ++.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.
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]
źródło
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.źródło
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.
źródło
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!
źródło
#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; }
źródło
#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:
źródło
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_string
argument do funkcji i upewnij się, że nie dopełniasz łańcucha, gdy długość ma być większa niż rozmiar.źródło
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.
źródło
#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); }
źródło