Frage Funktionsaufruf

Ich habe in main() einen 2-D-Vektor namens arr mit z Zeilen und s Spalten. Den möchte ich an die Funktion "Out" zwecks Ausgabe übergeben.
In main() sieht das so aus:

Out(float_arr, z, s); //arr=2-D-Vektor, z=Zeilen, s=Spalten

Den Funktionskopf von Out habe ich so implementiert:

void Out(const vector<vector<float> >temp, int z, int s)
{
}

Habe das richtig gemacht? Ist das const ok, denn ich gebe ja nur aus. Sollte ich noch eine Referenz mit übergeben? Der Vektor soll ja nicht kopiert werden, soll ich will ihn einfach nur auslesen.

Danke.

Ponto

Es reicht:

void Out(vector<vector<float> > const & temp)
{
}

Du musst z und s nicht mit übergeben. Das weiss der vector von alleine. temp.size() und temp[i].size() helfen dir.

Und es ist gut per Referenz zu übergeben, damit die vector nicht kopiert werden.

Danke, Ponto.
Eine Frage noch: der Name ist egal? Ich kann also temp lassen, muss nicht float_arr nehmen?

Ponto

grapefruit schrieb:

Danke, Ponto.
Eine Frage noch: der Name ist egal? Ich kann also temp lassen, muss nicht float_arr nehmen?

Der Name ist innerhalb der normalen Grenzen (legaler Bezeichner, keine Keywords, ...) egal.

Tja, muss nochmal fragen.

int z = temp.size();
int s = temp[z].size(); //s undefiniert.

Wie muss es lauten?
Danke.

rüdiger

std::size_t z=temp.size();
std::size_t s=temp[z-1].size();

int nimmt man nicht für größen

Mein Compiler sagt wörtlich:
"In Borland-Implementation des ANSI C-Standards, ist der Typ size_t unsigned."
Ist damit unsigned int gemeint?

Shade Of Mine

grapefruit schrieb:

Mein Compiler sagt wörtlich:
"In Borland-Implementation des ANSI C-Standards, ist der Typ size_t unsigned."
Ist damit unsigned int gemeint?

Nein. Es ist damit ein Typ gemeint, der keine negativen Werte speichern kann.

Ob das jetzt unsigned int, unsigned long oder unsigned megagross ist, ist implementationsabhaengig.

size_t ist der Typ den du verwendest, wenn du groessenangaben hast - denn dafuer ist er da.

Ponto

std::vector< std::vector< float > >::size_type sollte sehr sicher sein.

Wie verzichte ich denn auf die Übergabe von z uns s, wenn ich eine Init-Liste habe, so wie hier:

mathplane::mathplane(int z, int s, vector<vector<float> >const &temp) : m_arr(z)

Ponto

grapefruit schrieb:

Wie verzichte ich denn auf die Übergabe von z uns s, wenn ich eine Init-Liste habe, so wie hier:
mathplane::mathplane(int z, int s, vector<vector<float> >const &temp) : m_arr(z)

Genauso:

mathplane::mathplane(vector<vector<float> >const &temp) : m_arr(temp.size())

Ich darf nochmal nachfragen?

In main() erstelle ich den 2-D-Vektor und übergebe ihn an die Klasse:

int z = 4, s = 8;
vector<vector<float> >vec(z, vector<float>(s));
//jetzt Übergabe an Klasse
mathplane ma(vec);

In der Klasse mathplane sieht der Konstruktor wie folgt aus:

mathplane::mathplane(vector<vector<float> >const &temp) : m_arr(temp.size())
{
	size_t m_zeilen = temp.size(); 
	size_t m_spalten = temp[m_zeilen-1].size();
	for (int i = 0; i < m_zeilen; i++)
		m_arr[i].resize(m_spalten); //gehts auch ohne resize?
	//Füllen von m_arr mit Werten aus temp
	for (int a = 0; a < m_zeilen; a++)
		for (int b = 0; b < m_spalten; b++)
			m_arr[a][b] = temp[a][b];
}

Welche Verbesserungsmöglichkeiten muss ich noch vornehmen?

- eine andere Initialisierungsliste?
- m_arr intelligenter füllen?
- kein resize?
- noch was ganz anderes?

Ich bin leider noch nicht so firm, sorry, wenns allzu banal ist, was ich frage. Aber die Bücher, die ich konsultiert habe, haben mir bei dieser Frage nicht wirklich weiter geholfen.
Danke.