Problem mit mehrdemensionalen Arrays und Funktionen

Hy,
ich hätte da einmal eine Frage zum Managen von merdemensionalen Arrays und Funktionen.

Ich habe jetzt eine Funktion, die zwei Arrays mit variabler Größe ausfüllen soll.
Der erste Array ist eindemensional, wird per Parameter übergeben und macht auch keinerlei Probleme.
Der zweite Array ist zweidemensional und wie schon gesagt mit variablen (ich sage mal)"Grenzen". Es ist egal, ob er seine Werte per Parameter eingespeißt kriegt, oder per Rückgabewert.

Das Problem ist jetzt, das ich nicht weiß wie ich ArrayZwei[VariableGrenze][VariableGrenze] per Parameter übergeben soll bzw. wie ich solch einen Array als Rückgabewert zurück geben soll.

Vielen Dank im Vorraus,
Icy

virtuell Realisticer

Tach,

ein zweidimensionales Array ist im Prinzip nichts weiter, als ein Zeiger auf
einen Zeiger auf ein char, sprich 'char**'. Ich nehme mal an, du hast sowas
in der Art:

char** var = new char*[first_dim];

    for(size_t i = 0; i < first_dim; ++i)
        var[i] = new char[second_dim];

Dann kann deine Funktion z. B. so aussehen:

void func(char** array, const size_t& first_dim, const size_t& second_dim) {
    //tue hier was mit array z. b. ausgabe
    for(size_t i = 0; i < first_dim; ++i)
        for(size_t j = 0; j < second_dim; ++j)
            std::cout<< array[i][j] << std::endl;
}

//speicher wieder freigeben, wenn var nicht mehr gebraucht
for(size_t i = 0; i < first_dim; ++i)
    delete[] var[i]; //zweite dimension
delete[] var; //erste dimension

Ich hoffe ich hab dich richtig verstanden, ansonsten einfach nochmal nachfragen.

mfg
v R

Naja, mein Problem wurde gelöst.
Das mit dem "doppelten Zeiger" habe ich zwar gewusst, jedoch habe ich nicht den Codeschnipselbenutzt:

char** var = new char*[first_dim];

    for(size_t i = 0; i < first_dim; ++i)
        var[i] = new char[second_dim];

Wobei ich bei neuen Frage bin. Ich brauche sie zwar nicht bei der Lösung irgendwelcher Probleme, aber es wäre nett wenn ihr sie mir beantworten könntet:
- Was hat es mit size_t auf sich? Ich hab es einfach gegen int ausgetauscht.
- Kann man den Codeschnipsel nicht bisschen abkürzen?
- Wieso muss es überhaupt so aufwändig geschrieben werden? Wieso geht nicht einfach"char var[first_dim][second_dim]"? Also ich meine es kommt dann ja bei der Parameterübergabe zu Problemen.

Danke für die Antwort und schon im vorraus

HumeSikkins

Was hat es mit size_t auf sich? Ich hab es einfach gegen int ausgetauscht

size_t ist ein typedef auf einen unsigned-Typ, der z.B. in <cstddef> definiert und gerne für Größenangaben benutzt wird.

- Kann man den Codeschnipsel nicht bisschen abkürzen?
- Wieso muss es überhaupt so aufwändig geschrieben werden? Wieso geht nicht einfach"char var[first_dim][second_dim]"? Also ich meine es kommt dann ja bei der Parameterübergabe zu Problemen.

http://www.c-plusplus.net/forum/viewtopic.php?t=58906

Der Thread hilft mir nicht weiter.
Ich möchte wissen, wie man aus

char** var = new char*[first_dim];

    for(size_t i = 0; i < first_dim; ++i)
        var[i] = new char[second_dim];

etwas kürzeres machen kann.
Wenn ich folgendes schreibe:

int var[first_dim][second_dim];
int (*p)[second_dim] = var;

kann ich das ganze keiner Funktion übergeben.
Ich will ja keine Referenz, ich will das der Funktion übergeben.
Falls ich irgendwas nicht verstanden haben sollte, verbessert mich bitte.

virtuell Realisticer

Du kannst das auch mit einem vector<> machen:

typedef std::vector<type> vec_type;
typedef std::vector<vec_type> vec_vt;

vec_vt var;

//var mit vec_type fuellen
for(size_t i = 0; i < first_dim; ++i) {
    var.push_back(vec_type()); //neuen vector speichern
    for(size_t i = 0; i < second_dim; ++i)
        var[i].push_back(data); //data ist vom typ 'type'
}

//eine funktion, welcher du diesen vector uebergeben kannst, koennte so aussehen:
void print_vec(const vec_vt& vec) {
    for(size_t i = 0; i < vec.size(); ++i)
        //angenommen der typ ist 'int'
        std::copy(vec[i].begin(), vec[i].end(), std::ostream_iterator<int>(cout, "\n"));
}

Damit hast du dann auch nicht mehr das Problem, dass du dich mit der Speicher-
verwaltung rumschlagen musst, da std::vector das fuer dich erledigt.

mfg
v R

Danke für den Tip mit den Vektoren. Jedoch ist die Syntax dann genau so lange.

Also wenn ich das jetzt richtig verstanden habe, kann man da nichts machen um die drei Zeilen zu verkürzen?

virtuell Realisticer

Icy schrieb:

Danke für den Tip mit den Vektoren. Jedoch ist die Syntax dann genau so lange.

Also wenn ich das jetzt richtig verstanden habe, kann man da nichts machen um die drei Zeilen zu verkürzen?

Nein, du koenntest sie hoechstens hinter einer Funktion verstecken, um dir
entsprechende Schreibarbeit, bei mehrfacher Anwendung, zu sparen.

mfg
v R

Jester

Doch das geht.

std::vector<std::vector<int> > myVector(dim1, std::vector<int>(dim2, defaultwert));

erzeugt einen Vector mit dim1 Zeilen, dim2 Spalten vorinitialisiert mit defaultwert. Nich schön, aber selten.

Nee, wollte ja bei den Standart Arrays bleiben.
Trotzdem Danke. Mein Problem hat sich soweit erledigt also Danke...