从 integer 数组构建一个字符串（字符指针）

Question

I am doing an assignement that requires me to build a string from a matrix of integer (in a certain way, not the point of this question). the string has to be a char pointer.

My code is as follows

void funcMatrix(int *matrix, int rows, int columns, char* outBuffer)
{
    int j,i;
    int element =0;
     
    for (i = 0; i < rows; ++i) 
    {
        for (j = 0; j < columns; ++j) 
        {
            malloc(sizeof(matrix[(i * columns) + j]));
            sprintf(outBuffer + (element++),"%d", matrix[(i * columns) + j]);
        }
    }
}

For a matrix

{{ 3, 8},
{  7, 12},
{  0, 10} };

outBuffer should be 38712010 but my code prints 3871010 (because it taking 1 digit from 12)

how can I solve this please? I am stcuk

Idealy I need 3, 8, 7, 12, 0, 10

Answer 1

The problem is that you are overwriting the already written digits again!

How many digits will the number 12 need? And how many digits do you advance your pointer?

The safest way to handle this is using the result of sprintf function, which is the number of bytes it wrote (not including the terminating null character):

element += sprintf(outBuffer + element, "%d", matrix[i * columns + j]);

I personally would additionally prefer to use pointers:

// char* ob = outBuffer;
// actually, we don't even need that one, we do not reuse the parameter
// itself afterwards anyway, so we can simply move that one:

outBuffer += sprintf(outBuffer, "%d", matrix[i * columns + j]);

Furthermore I recommend providing buffer size as well, which helps preventing writing beyond its bounds:

void funcMatrix
(
    int *matrix, int rows, int columns, char* outBuffer, size_t bufferSize
)
{
    // ...
        int num = snprintf(outBuffer, bufferSize, "%d", matrix[i * columns + j];
        //         ^
        outBuffer += num;
        bufferSize -= num;
    // ...
}

Answer 2

For starters this declaration of the function

void funcMatrix(int *matrix, int rows, int columns, char* outBuffer);

does not make a sense.

As your matrix is interpreted as a one-dimensional array then there is no need to split the total number of elements in the array into the number of rows and the number of columns because you could call the function like

funcMatrix( matrix, rows * columns, outBuffer );

That is the function could have only three parameters.

As the array matrix is not being changed within the function then the corresponding parameter should be declared with the qualifier const .

If the matrix may not have negative numbers then its element type should have the type unsigned int. Otherwise either you need also to output the minus sign for negative numbers or write the code such a way that it will ignore the minus sign.

This statement with a memory allocation

malloc(sizeof(matrix[(i * columns) + j]));

does not make a sense because the returned value is not used. So the only effect of the statement is a memory leak.

As a number in the matrix can contain more than one digit then this expression

sprintf(outBuffer + (element++),"%d", matrix[(i * columns) + j]);
                    ^^^^^^^^^^^         

is in general incorrect.

The function can look the following way as it is shown in the demonstrative program below.

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

size_t total_numbers_length( const unsigned int a[], size_t n )
{
    const int Base = 10;
    
    size_t length = 0;
    
    for ( size_t i = 0; i < n; i++ )
    {
        unsigned int value = a[i];

        do
        {
            ++length;
        } while ( value /= Base );
    }
    
    return length;
}

char * fill_string_from_array( char *buffer, const unsigned int *a, size_t n )
{
    for ( char *p = buffer; n-- ; )
    {
        int  offset = sprintf( p, "%u", *a++ );
        
        if ( offset  <= 0 ) break;
        else ( p += offset );
    }
    
    return buffer;
}

int main(void) 
{
    unsigned int a[] = { 3, 8, 7, 12, 0, 10 };
    const size_t N = sizeof( a ) / sizeof( *a );

    char *buffer = malloc( total_numbers_length( a, N ) + 1 );
    
    if ( buffer )
    {
        puts( fill_string_from_array( buffer, a, N ) );
    }
    
    free( buffer );
    
    return 0;
}

The program output is

38712010