Arrays, Zeiger und Funktionen

RobertB

Hallo.
Ich habe ein Verständnisproblem, da C++ für mich eine unerklärliche Sache macht (hat aber bestimmt seinen Grund).
Ich habe das untere Programm geschrieben und möchte jetzt einfach im Programm "normale" den Zeiger auf das Array "c" übergeben. Erstmal das Programm:

#include <iostream>
#include <conio.h>

int * normale( int vektor[2] )
{
	int c[2]; // Definiere das Array
	int *p=&c[0]; // Definiere den Zeiger auf das erste Element des Arrays

	c[0] = vektor[0] - vektor[1];
	c[1] = vektor[0] * vektor[1];

	return &c[0];
	return p;	
}

int main()
{
	int y[2] = {7, 2};
	int i;
	int *zeiger;

	zeiger = normale(y);
	std::cout << *zeiger << std::endl;
	std::cout << *zeiger << std::endl;

	zeiger = normale(y);
	zeiger++;
	std::cout << *zeiger << std::endl;

	getch();

	return 0;
}

Und mein Problem tritt hier auf:

zeiger = normale(y);
	std::cout << *zeiger << std::endl;
	std::cout << *zeiger << std::endl;

	zeiger = normale(y);
	zeiger++;
	std::cout << *zeiger << std::endl;

Ich hole mir den Zeiger von der Funktion. Die erste Ausgabe gibt mir das richtige heraus. Doch die zweite Ausgabe ergibt schon etwas anderes, was ich nicht verstehe. Ich bearbeite den Zeiger doch gar nicht, und dieser ruft was anderes auf?

Wenn ich

zeiger = normale(y);
	std::cout << zeiger << std::endl;
	std::cout << zeiger << std::endl;

aufrufe, also die Adresse ausgebe, kommt die selbe heraus. Wieso aber wird dann mit "*zeiger" jeweils ein anderer Inhalt ausgegeben??

Und zuletzt: wenn ich nun den Zeiger auf das nächste Feld im Array zeigen lassen möchte, mache ich es ja so wie

zeiger++;
	std::cout << *zeiger << std::endl;

Nur, dann zeigt er auch nicht auf das richtige Element, sondern auf irgendeinen Quatsch. Ich muss, bevor ich den Zeiger erhöhe, zuerst

zeiger = normale(y);
	zeiger++;
	std::cout << *zeiger << std::endl;

machen, dem Zeiger also nochmal neu definieren. Wieso? Ich habe doch seit der ersten Definitions des Zeigers durch die Funktion nicht geändert, und das Array musste im selben Speicher sein. Eine Vermutung von mir: Liegt es am Stack? Kenne mich da nicht so gut aus.

Vielen Dank für die Hilfe.

Nach Verlassen von normale, wird int c[2] zerstört. Du greifst auf Speicher zu der Dir nicht mehr gehört.

RobertB

Mit c[2] meinst das ganze Array?
Weil, auf c[0] kann ich zugreifen, nur auf c[1] nicht. Dass kann ich erst, wenn ich nochmal den Zeiger neu definiere.
Und wie kann man das besser lösen? Ich möchte eben ein array in einer Funktion ausgeben. Dachte, das geht nur über den Zeiger.

daddy_felix

Kauf dir ein gutes Grundlagenbuch.

Jonas OSDever

Wenn du ein Array per Funktion ausgeben willst, dann uebergib das Array und mach als zweiten Parameter die Anzahl der Elemente. Oder nutz gleich std::array .

Ach ja, das c[0] richtig ist und c[1] nicht muss nichts ungewoehnliches heissen. Der Standard garantiert fuer nix, wenn man in Speicher rumwerkelt, der einem nicht gehoert.

Und zu deinem Code: Was bezweckst du mit 2 return -Anweisungen nacheinander?

RobertB

Das mit den 2 return-Anweisungen war ein vertipper. Aber das mit dem std::array bzw. std::vector muss ich jetzt wohl suchen, wie das geht. Danke aber.

RobertB

Aber, wie übergebe ich jetzt einer Funktion einen Vektor?
Möchte das mit irgendwie mit

#include <vector>
std::vector<float> Vektorname;

daddy_felix

RobertB schrieb:

Aber, wie übergebe ich jetzt einer Funktion einen Vektor?

so, wie jeden anderen Typ auch --> Grundlagenbuch

Wenn du nur lesen willst, übergibst du den vector idealerweise als const-reference. Wenn du ihn in der Funktion füllen möchtest, dann als non-const Reference. Alternativ kannst du ihn auch in der Funktion erstellen und dann zurückgeben (per value).

RobertB schrieb:

Möchte das mit irgendwie mit
#include <vector>
std::vector<float> Vektorname;

soweit gar nicht schlecht, mit diesen Zeilen hast du dir schonmal einen (leeren) std::vector erstellt.

daddy_felix schrieb:

Wenn du nur lesen willst, übergibst du den vector idealerweise als const-reference. Wenn du ihn in der Funktion füllen möchtest, dann als non-const Reference. Alternativ kannst du ihn auch in der Funktion erstellen und dann zurückgeben (per value).

Möchte noch anmerken: Ersteres nennt sich call-by-reference, letzteres call-by-value. Dass der TE auch das richtige googelt.

Passender Thread.

Sniped