String Padding in C

Tôi đã viết hàm này được cho là để thực hiện 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;
}

Nó hoạt động nhưng có một số tác dụng phụ kỳ lạ ... một số biến số khác bị thay đổi. Làm thế nào tôi có thể sửa lỗi này?

Có thể hữu ích khi biết rằng printf không đệm cho bạn, sử dụng% -10s làm chuỗi định dạng sẽ đệm đầu vào ngay trong một trường dài 10 ký tự

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

sẽ xuất ra

|Hello     |

Trong trường hợp này, biểu tượng - có nghĩa là "Căn trái", 10 có nghĩa là "Mười ký tự trong trường" và s có nghĩa là bạn đang căn một chuỗi.

Định dạng kiểu printf có sẵn ở nhiều ngôn ngữ và có nhiều tài liệu tham khảo trên web. Đây là một trong nhiều trang giải thích các cờ định dạng. Như thường lệ , trang printf của WikiPedia cũng có ích (hầu hết là một bài học lịch sử về mức độ lan truyền rộng rãi của printf).

Đối với 'C', có cách sử dụng [s] printf thay thế (phức tạp hơn) mà không yêu cầu bất kỳ malloc () hoặc định dạng trước nào, khi muốn có đệm tùy chỉnh.

Mẹo là sử dụng các chỉ định độ dài '*' (tối thiểu và tối đa) cho% s, cộng với một chuỗi chứa đầy ký tự đệm của bạn với độ dài tiềm năng tối đa.

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" có thể được đặt trước HOẶC sau "% s" của bạn, tùy thuộc vào mong muốn cho phần đệm TRÁI hoặc PHẢI.

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

Tôi thấy rằng PHP printf ( ở đây ) hỗ trợ khả năng cung cấp một ký tự đệm tùy chỉnh, sử dụng dấu nháy đơn (') theo sau là ký tự đệm tùy chỉnh của bạn , trong định dạng% s.
printf("[%'#10s]\n", $s); // use the custom padding character '#'
sản xuất:
[####monkey]

Bạn phải đảm bảo rằng chuỗi nhập có đủ không gian để chứa tất cả các ký tự đệm. Thử đi:

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

Lưu ý rằng tôi đã phân bổ 11 byte cho hellochuỗi tài khoản cho dấu chấm hết null ở cuối.

Đối số bạn đã truyền "Hello" nằm trên vùng dữ liệu không đổi. Trừ khi bạn đã cấp đủ bộ nhớ cho chuỗi ký tự *, nó sẽ chạy quá mức cho các biến khác.

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

Chỉnh sửa: Đã sửa từ ngăn xếp thành vùng dữ liệu không đổi.

Ồ được rồi, có lý. Vì vậy, tôi đã làm điều này:

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

Cảm ơn!

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

Đầu ra:

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

Bản thân chức năng này có vẻ ổn đối với tôi. Vấn đề có thể là bạn không phân bổ đủ không gian cho chuỗi của mình để chèn nhiều ký tự vào đó. Bạn có thể tránh vấn đề này trong tương lai bằng cách truyền một size_of_stringđối số cho hàm và đảm bảo rằng bạn không chèn chuỗi khi độ dài sắp lớn hơn kích thước.

Một điều chắc chắn sai trong hàm tạo thành câu hỏi ban đầu trong chuỗi này, mà tôi chưa thấy ai đề cập đến, đó là nó đang nối các ký tự phụ vào cuối chuỗi ký tự đã được chuyển vào dưới dạng tham số. Điều này sẽ cho kết quả không thể đoán trước. Trong cuộc gọi ví dụ của hàm, chuỗi ký tự "Xin chào" sẽ được mã hóa cứng vào chương trình, vì vậy có lẽ việc nối vào cuối của nó sẽ gây nguy hiểm ghi đè lên mã. Nếu bạn muốn trả về một chuỗi lớn hơn chuỗi ban đầu thì bạn cần đảm bảo rằng bạn phân bổ động chuỗi và sau đó xóa nó trong mã gọi khi bạn hoàn tất.

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