Achso, jetzt, aha. Irgendwie habe ich mal wieder Unfug gelesen, naemlich "2d Array" statt "2. Array". Drum dachte ich Du hast den Loesungsansatz schon.
Wenn Du ein 3-d Array mit festen Dimensionen hast, kannst Du das ganze auch als 2-d bzw. 1-d Array erstellen. Du musst nur wissen, welche Groesse Deine Dimensionen haben. (Macht man in der Bildverarbeitung staendig).
Bleistiel:
Code:
/* Ein 3-d Array, das auf 2 Dimensionen Strings (die dritte DImension) speichert */
/* Also eine 2-d Stringtabelle */
#include <console>
#include <core>
/* Funktion zum Befuellen der Tabelle mit Strings */
set_string_2d( zweiD[], dX, dY, maxlen, x, y, string[] ) {
// Position im der Tabelle bestimmen.
new insert = (y*dX + x) * maxlen;
new pos = insert;
new i = 0;
new len = strlen( string );
if ( len > maxlen ) len = maxlen;
/* String an dieser Stelle hineinschreiben (in die 3. Dimension) */
while ( pos < insert+maxlen ) {
while ( pos < insert+len ) {
zweiD[pos] = string[i];
++pos; ++i;
} // while
/* Auffuellen mit Nullen */
zweiD[pos] = '^0';
++pos;
} // while
}
/* Funktion zum Ausgeben der Tabelle */
print_string_2d( const dreiD[], dX, dY, dZ ) {
new x,y,z;
new cChar;
new pos = 0;
for ( y = 0; y < dY; ++y ) {
for ( x = 0; x < dX; ++x ) {
for ( z = 0; z < dZ; ++z ) {
cChar = dreiD[pos]?dreiD[pos]:' ';
printf( "%c", cChar );
++pos;
} // for
printf( " " );
} // for
printf( "^n" );
} // for
}
/* Funktion zum Auslesen eines Strings */
get_string_2d( string[], x, y, zweiD[], dX, dY, dZ ) {
new pos = (y*dX + x) * dZ;
new i = 0;
while ( zweiD[pos] != 0 ) {
string[i] = zweiD[pos];
++pos; ++i;
} // while
zweiD[pos] = '^0';
}
/* Das ganze Testen */
main() {
const dX = 4;
const dY = 5;
const dZ = 12;
const dim = dX * dY * dZ;
/* Dies ist nun ein Array in dem die drei Dimensionen hintereinenader stehen */
/* Reihenfolge ist z,x,y. Man kann sich das ganze als 2-d Flaeche vorstellen,
auf der Hochhaeuser Stehen. Beim Durchlaufen klappert man erst alle
Stockwerke des Hauses an Position (0,0) ab, dann (1,0), (2,0), usw. */
new einD[dim];
new string[dZ];
set_string_2d( einD, dX, dY, dZ, 0, 0, "null" );
set_string_2d( einD, dX, dY, dZ, 1, 0, "eins" );
set_string_2d( einD, dX, dY, dZ, 2, 0, "zwei" );
set_string_2d( einD, dX, dY, dZ, 3, 0, "drei" );
set_string_2d( einD, dX, dY, dZ, 4, 0, "vier" );
set_string_2d( einD, dX, dY, dZ, 0, 1, "fuenf" );
set_string_2d( einD, dX, dY, dZ, 1, 1, "sechs" );
set_string_2d( einD, dX, dY, dZ, 2, 1, "sieben" );
set_string_2d( einD, dX, dY, dZ, 3, 1, "acht" );
set_string_2d( einD, dX, dY, dZ, 4, 1, "neun" );
set_string_2d( einD, dX, dY, dZ, 0, 2, "zehn" );
set_string_2d( einD, dX, dY, dZ, 1, 2, "elf" );
set_string_2d( einD, dX, dY, dZ, 2, 2, "zwoelf" );
set_string_2d( einD, dX, dY, dZ, 3, 2, "dreizehn" );
set_string_2d( einD, dX, dY, dZ, 4, 2, "vierzehn" );
set_string_2d( einD, dX, dY, dZ, 0, 3, "fuenfzehn" );
print_string_2d( einD, dX, dY, dZ );
get_string_2d( string, 2, 1, einD, dX, dY, dZ );
printf( "^n^nString an Postition (%d,%d) ist '%s'.", 2, 1, string );
}
Ergibt als Ergebnis:
Code:
null eins zwei drei vier
fuenf sechs sieben acht neun
zehn elf zwoelf dreizehn vierzehn
fuenfzehn
String an Postition (2,1) ist 'sieben'.
Obiger Code ist schnell zusammengeschrieben (aber gecheckt) und daher kein Beispiel fuer besondere Effizienz.
*edit* Super, und das nennt sich fixed font
*edit*
