ich habe heute in meinem Code ein Problem festgestellt und weiß ehrlich gesagt nicht, woran es liegt. Und zwar habe ich ein Array A, welches insgesamt 1000 double-Werte aufnehmen kann (werden aus einer *.csv ausgelesen). Das klappt auch alles so wie gewünscht.

In der nachfolgenden Berechnung werden nun jedoch immer nur Gruppen von 10 Zahlen benötigt (Indizes 0-9, 10-19 etc. aus dem Array A). Daher werden diese double-Werte in ein Array B mit der Länge 10 eingefügt und an eine Funktion übergeben. Nach dem ersten Aufruf der Funktion zum weiteren Rechnen mit dem Array B und der Rückgabe der berechneten Werte an die aufrufende Funktion ist jedoch das Array A verändert (an min. einer Position (aufgefallen ist es mir an der Position 12) ist eine 0.0 anstatt der ursprünglichen Zahl zu finden). Dies kann ich mir ehrlich gesagt gar nicht erklären, bin hier echt ratlos, woran das liegen könnte. Schließlich wird das Array A gar nicht übergeben, sondern dient lediglich als Datenspeicher.

Kann mir hier jemand weiterhelfen? Das wäre wirklich sehr hilfreich!

Vielen Dank im Voraus!!

Viele Grüße
Michael

Will heissen, dass es schwer ist das Problem zu lokalisieren, wenn kein Code präsentiet wird.

PS. Es ist übrigens immer sehr hilfreich die betreffende Code-Stelle mit in den Beitrag zu schreiben.

Weil ich aber C++ und vor allem die STL mag, hier noch eine alternative Variante deiner Funktion:

template <typename Iterator>
void process_tenner(Iterator first, Iterator last)
{
  ... // hier wird mit den iteratoren gerechnet
}

for (vector<TYP>::const_iterator it=vec.begin(), end=vec.end(); it < end; it+=10)
  process_tenner(it, end);

Weil ein const_iterator übergeben wird ist quasi ausgeschlossen, dass etwas verändert wird und ausserdem geht das mit allen Arrays (std::vector, std::list, boost::array, C-Array, ...)

Erst einmal vielen Dank für die Antworten. Prinzipiell sieht meine Funktion genauso aus wie nachfolgend dargestellt:

int main(int argc, char** argv)
{
	const int anzahl=1000;
	const int anzahl_gruppe=10;
	int j;
	int i;
	double daten[anzahl]; //Erzeugen des Datenarrays
	double daten_gruppe[anzahl_gruppe]; //Erzeugen des Arrays für jeweils 10 benachbarte Werte
	daten_einlesen(daten,anzahl); //Aufrufen der Funktion zum Einlesen der Daten
	double berechnungsergebnis[anzahl_gruppe];
	//Deklaration weiterer Variablen

	for(j=0;j<anzahl-anzahl_gruppe;j=j+anzahl_gruppe) //Subtraktion erforderlich zum Einhalten der Arraygrenzen
	{
		for(i=0;i<anzahl_gruppe;i++)
		{
			daten_gruppe[i]=daten[j+i]; //Kopieren der Werte aus dem Datenarray in das kleinere Array
		}
		//nachfolgend wird die Funktion zur Berechnung aufgerufen
		berechnungen_durchfuehren(berechnungsergebnis,daten_gruppe);

		//weitere Anweisungen mit dem Array berechnungsergebnis

	}
}

.

Vielleicht hilft es ja beim Verständnis. Letztendlich werden also Werte im Array "daten" verändert, obwohl dies nicht an die Funktion übergeben wird.
Auf jeden Fall noch einmal vielen Dank für die Mühe & Arbeit!!

Viele Grüße
Michael

#include <cassert> // ganz oben im file

//...

assert(n >= 0 && n < anzahl_gruppe); // wenn anzahl_gruppe hier nicht bekannt ist schreib einfach den entsprechenden wert als konstante hin, 
                                     // ist ja nur zum testen
daten_gruppe[n] = ...

Dann lass das Programm laufen, und wenn es Bumm macht hast du deinen Fehler gefunden.

Woher weiß denn berechnungen_durchfuehren() an welche Stelle es in berechnungsergebnis[] schreiben darf?

Vielen Dank für die Antworten! Ich werde das gleich mal ausprobieren und dann hoffentlich zur Lösung kommen bzw. den Fehler finden.

@DirkB: in der aufzurufenden Funktion läuft wieder eine for-Schleife ab, in der 10 Ergebnisse erzeugt werden. Da die Funktion berechnungen_durchfuehren ein Zeiger auf berechnungsergebnis[] übergeben bekommt, sollte das meiner Meinung nach gehen. Dazu muss ich sagen, dass ich allerdings erst seit kurzer Zeit mit C++ beschäftige (vorher nur Java und dort sind Arrays als Rückgabe kein Problem), muss das auch nicht unbedingt richtig sein .

Euch noch einen schönen Abend!

Viele Grüße
Michael

... in der aufzurufenden Funktion läuft wieder eine for-Schleife ab, in der 10 Ergebnisse erzeugt werden

Sorry, da war ich etwas verwirrt. Das passt dann schon.

oder man nimmt einfach .at(..).

Und du meinst das funktioniert?

double x[100];
double* ptr = x;
ptr.at(101);