Ich möchte die Anzahl der "Reihen" bei einem zweidimensionalem Array rausbekommen.
Dazu habe ich im Internet auch schon folgenden Trick gefunden, nur das der bei mir nicht funktioniert.

sizeof(_values) / sizeof(_values[0])

_values sieht dabei so aus

const char* values[1][2];
values[0][0] = "foo";
values[0][1] = "bar";

Das ist jetzt natürlich nur ein Beispiel, theoretisch sind n solcher Paare möglich. Bzw sollen möglich sein.

Wenn ich mir jetzt also mittels

int valueCount = sizeof(_values) / sizeof(_values[0]);

die Anzahl der Paare ermitteln möchte bekomme ich immer 0 raus.
Ich habe mir das ganze mal im Debugger angeschaut und folgende Werte tauchen auf:
sizeof(_values) ist 4
sizeof(_values[0]) ist 8
Das dabei für valueCount dann 0 rauskommt ist somit also klar.

Warum beim ersten 4 rauskommt ist mir soweit auch klar (Größe des Pointers), daher vermute ich das die Größe von einem const char* wohl 8 ist??
Aber wie bekomme ich das jetzt so hin das es funktioniert?

Ich habe auch bereits gelesen das man das ganze mit sog. Vektoren machen kann, allerdings würde ich darauf gern verzichten da ich momentan noch in der Lern-/Verstehphase bin und es doch bestimmt auch ohne Vektoren geht?

'n Gruß

Größe des Pointers

Ne. sizeof von einem Objekt repräsentiert die Größe des Objektes. Ein Array ist ein Objekt und stellt keine Ausnahme dar. Bei mir ergibt sizeof(values)/sizeof(values[0]) (beachte dass ich keinen Unterstrich in den Namen setze) das erwartete Ergebnis, 1.

Ist bei dir _values (also mit dem Unterstrich) ein Zeiger auf das Array? Beachte aber das alle Zeiger die gleiche Größe haben.

Ich habe auch bereits gelesen das man das ganze mit sog. Vektoren machen kann, allerdings würde ich darauf gern verzichten da ich momentan noch in der Lern-/Verstehphase bin und es doch bestimmt auch ohne Vektoren geht?

Mit C++11 und <type_traits> geht das ganz einfach: std::extent<decltype(values)>::value (oder std::extent<decltype(values), 1>::value für die größe zweite Dimension, bzw. die Anzahl der Spalten).

Also mein _values ist ein Funktionsparameter, das wird dann vermutlich ein Zeiger sein?

Ja.

phost schrieb:

Lässt sich daraus irgendwie ein "echtes" Array machen?

Nein.

Mit C++11 und <type_traits> geht das ganz einfach: std::extent<decltype(values)>::value (oder std::extent<decltype(values), 1>::value für die größe zweite Dimension, bzw. die Anzahl der Spalten).

Höre übrigens nicht auf Arcoth, der trollt nur rum ...

#include <array>
#include <iostream>

void foo( std::array< std::array< char const *, 1 /* <<-- wtf? */ >, 2 > bar )
{
	std::cout << bar.size() << '\n';
}

int main()
{
	std::array< std::array< char const *, 1 /* <<-- wtf? */ >, 2 > values
	{{
		{ "foo" },
		{ "bar" }
	}};

	foo( values );
}

Um mal ne Meinung noch einzuholen..
Das ganze sollte dazu dienen das ich eine Datenbank-Klasse habe mit der ich eine Art Prepared Statements zusammenbekomme, dazu wollte ich die entsprechenden Wertepaare in der Form von diesem Array übergeben.
Mein Ansatz jetzt ist das ich in der Klasse selbst das Array so schonmal anlege und dann mittels einer Funktion Stück für Stück die Werte an die Klasse übergebe.
Ist das sinnvoll? Also das ich in einer Klasse dann halt ein dynamisches Array erzeuge zur Speicherung?
Und auch hier: würde gerne zunächst auf Vektoren verzichten (einfach damit ich es zunächst mal lerne wie man mit sowas umgeht).

Höre übrigens nicht auf Arcoth, der trollt nur rum ...

Wo bitte trolle ich herum?

Das values in meinem Code-Schnipsel bezieht sich offensichtlich auf das values im OP - ein (echtes) Array womit es auch einwandfrei funktioniert.
http://coliru.stacked-crooked.com/a/a04c60c612f38b1c
Dass sich der OP auf einen Zeiger bezieht konnte ich natürlich nicht wissen.

Mein Ansatz jetzt ist das ich in der Klasse selbst das Array so schonmal anlege und dann mittels einer Funktion Stück für Stück die Werte an die Klasse übergebe.

Warum passiert das Stück für Stück - zu Lernzwecken?

Willst du in jedem Stück dieselbe Anzahl an Elementen reinkopieren? Oder soll das variabel bleiben? In letzterem Fall kannst du bspw. zwei Zeiger (oder allgemeiner Iteratoren) nehmen, oder einen Zeiger(/Iterator) und die Anzahl. Was du aber nicht verwenden solltest ist Swordfishs pass-by-value Variante.

Und um dann später die Datenpaare zu verarbeiten wollte ich mit einer for-Schleife das values-Array durchlaufen.

Um mal ein Beispiel zu geben was eigentlich passieren soll..
Ich habe eine SQL-Anfrage

SELECT ID FROM table WHERE Name=':foo' AND Value=':bar'

Diese Anfrage wird jetzt zunächst an die Datenbank-Klasse übergeben.
Anschließend werden dann die einzufügenden Werte übergeben und "intern" soll das dann alles in einem Array in der Form

values[0][0] = foo
values[0][1] = DerName
values[1][0] = bar
values[1][1] = IrgendeinWert

vorliegen.
Dabei wird die Größe von values natürlich größer, abhängig davon wie viele Parameter die SQL-Anfrage beinhaltet.
Anschließend wollte ich dann also das values-Array durchlaufen und mittels regex replace die entsprechenden Werte in die Abfrage einfügen.
Warum ich diesen Umweg gehe ist der, dass es irgendwann auch möglich sein soll diese Datenbank-Klasse als Schnittstelle für Usereingaben zu verwenden und da muss ich natürlich die Eingaben erst prüfen und so weiter, daher wird diese Überprüfung dann innerhalb einer extra Funktion "abgekapselt".

Das steht soweit auch alles schon, mir fehlt lediglich noch eine Methode um eben die Größe des intern vorliegenden Arrays zu ermitteln.
Ich habe gestern auch noch mit dynamisches Arrays rumgespielt, allerdings kam ich damit noch nicht sehr weit.

die Anzahl der übergebenen Datenpaare ist variabel, [...]

Dann willst du kein Array. Nicht in C++. Zumindest nicht vor dem nächsten Standard. Yeah, noch ein Kasperl.