#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.

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?

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

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.

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.

Sniped