Wyściełanie strun w C

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

Sztuczka polega na użyciu określeń długości ' * ' (min i max) dla %s oraz ciągu wypełnionego znakiem wypełnienia 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 lewej lub prawej padding.

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

I found that PHP printf (tutaj ) obsługuje możliwość nadawania 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]

Należy upewnić się, że łańcuch wejściowy ma wystarczająco dużo miejsca, aby pomieścić wszystkie znaki dopełniające. Spróbuj tego:

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

Zauważ, że przypisałem 11 bajtów dla ciągu hello, aby uwzględnić Terminator null na końcu.

Podany przez Ciebie argument "Hello" znajduje się w obszarze danych stałych. Jeśli nie przydzieliłeś wystarczającej ilości pamięci do łańcucha znaków*, jest on zastępowany przez inne zmienne.

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

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

To ma sens. Więc zrobiłem to:

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

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

Sama funkcja wygląda dobrze dla mnie. Problemem może być to, że nie przydzielasz wystarczającej ilości miejsca na łańcuch do padu, że wiele znaków na nim. Możesz uniknąć tego problemu w przyszłości, przekazując do funkcji argument size_of_string i upewnij się, że nie wstawiasz ciągu, gdy długość ma być większa niż rozmiar.

Jedna rzecz, która jest zdecydowanie błędna w funkcji, która tworzy oryginalne pytanie w tym wątku, o którym nie widziałem, aby ktoś wspomniał, jest to, że łączy Dodatkowe znaki na końcu literalnego ciągu znaków, który został przekazany jako parametr. Da to nieprzewidywalne wyniki. W przykĹ 'adowym wywoĹ' aniu funkcji, literaĺ ' "Hello" bÄ ™ dzie zakodowany na twardo w programie, wiÄ ™ c prawdopodobnie poĹ 'Ä ... czenie siÄ ™ na jego kodzie niebezpiecznie bÄ ™ dzie zapisywaĺ' o kod. Jeśli chcesz zwróć ciąg znaków, który jest większy od oryginału, a następnie upewnij się, że przydzielasz go dynamicznie, a następnie usuwasz go w kodzie wywoławczym, gdy skończysz.

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

Wyjście:

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

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