How can I quickly printf 2 dimensional array of chars made of pointers to pointers without using a loop?

Question

I'm making ASCII game and I need performance, so decided to go with printf(). But there is a problem, I designed my char array as multidimensional char ** array, and printing it outputs garbage of memory instead of data. I know it's possible to print it with a for loop but the performance rapidly drops that way. I need to printf it like a static array[][]. Is there a way?

I did some example of working and notWorking array. I only need printf() to work with nonWorking array.

edit: using Visual Studio 2015 on Win 10, and yeah, I tested performance and cout is much slower than printf (but I don't really know why is this happening)

#include <iostream>
#include <cstdio>

int main()
{
    const int X_SIZE = 40;
    const int Y_SIZE = 20;

    char works[Y_SIZE][X_SIZE];
    char ** notWorking;

    notWorking = new char*[Y_SIZE];
    for (int i = 0; i < Y_SIZE; i++) {
        notWorking[i] = new char[X_SIZE];
    }

    for (int i = 0; i < Y_SIZE; i++) {
        for (int j = 0; j < X_SIZE; j++) {
            works[i][j] = '#';
            notWorking[i][j] = '#';
        }
        works[i][X_SIZE-1] = '\n';
        notWorking[i][X_SIZE - 1] = '\n';
    }
    works[Y_SIZE-1][X_SIZE-1] = '\0';
    notWorking[Y_SIZE-1][X_SIZE-1] = '\0';

    printf("%s\n\n", works);
    printf("%s\n\n", notWorking);

    system("PAUSE");
}

Note: I think I could make some kind of a buffer or static array for just copying and displaying data, but I wonder if that can be done without it.

Answer 1

If you would like to print a 2D structure with printf without a loop, you need to present it to printf as a contiguous one-dimension C string. Since your game needs access to the string as a 2D structure, you could make an array of pointers into this flat structure that would look like this:

Array of pointers partitions the buffer for use as a 2D structure, while the buffer itself can be printed by printf because it is a contiguous C string.

Here is the same structure in code:

// X_SIZE+1 is for '\n's; overall +1 is for '\0'
char buffer[Y_SIZE*(X_SIZE+1)+1];
char *array[Y_SIZE];
// Setup the buffer and the array
for (int r = 0 ; r != Y_SIZE ; r++) {
    array[r] = &buffer[r*(X_SIZE+1)];
    for (int c = 0 ; c != X_SIZE ; c++) {
        array[r][c] = '#';
    }
    array[r][X_SIZE] = '\n';
}
buffer[Y_SIZE*(X_SIZE+1)] = '\0';
printf("%s\n", buffer);

Demo.

Answer 2

Some things you can do to increase performance:

• There is absolutely no reason to have an array of pointers, each pointing at an array. This will cause heap fragmentation as your data will end up all over the heap. Allocating memory in adjacent cells have many benefits in terms of speed, for example it might improve the use of data cache.

  Instead, allocate a true 2D array:

  char (*array2D) [Y] = new char [X][Y];
  

• printf as well as cout are both incredibly slow, as they come with tons of overhead and extra features which you don't need. Since they are just advanced wrappers around the system-specific console functions, you should consider using the system-specific functions directly. For example, the Windows console API. It will however turn your program non-portable.

  If that's not an option, you could try to use puts instead of printf, since it has far less overhead.

• Main performance issue with printf/cout is that they write to the end of the "standard output stream", meaning you can't write where you like, but always at the bottom of the screen. Forcing you to constantly redraw the whole thing every time you changed something, which will be slow and possibly cause flicker issues.

  Old DOS/Turbo C programs solved this with a non-standard function called gotoxy which allowed you to move the "cursor" and print where you liked. In modern programming, you can do this with the console API functions. Example for Windows.

• You could/should separate graphics from the rest of the program. If you have one thread handing graphics only and the main thread handling algorithms, the graphic updates will work smoother, without having to wait for whatever else the program is doing. It makes the program far more advanced though, as you have to consider thread safety issues.