wenn ich versuche ein Mehrdimensionales Array zu kopieren unterbricht das Programm manchmal mit einer Speicher Verletzung.

Kann mir vielleicht jemand sagen wo bzw. was der Fehler ist?

void myFunction(float* my2DArray, int row, int size){
	//Bei my2DArray handelt es sich um ein sequenziell
	//allokiertes zweidimensionales Array

	int i=0, j=0;
	float* my2DArrayCopy = new float(size);

	//Array kopieren
	for(i=0; i<row; i++)
	{
		for (j=0; j<size; j++){
			my2DArrayCopy[size*i+j]=my2DArray[size*i+j];
		}
	}

	//...

	//Array Kopie einfügen
	for(i=0; i<row; i++)
	{	
		for(j=0; j<size; j++){
			my2DArray[size*i+j] = my2DArrayCopy[size*i+j];
		}
	}
}

Die Anweisung in "0x5b0f6db6" verweist auf Speicher in "0x3f7ae154". Der Vorgang "read" konnte nicht auf dem Speicher durchgeführt werden.

Fällt vielleicht noch jemand ein Fehler auf?

PS:
Machst Du das zu Übungszwecken? Wenn nicht, bietet C++ deutlich bessere Möglichkeiten, sowas zu bewerkstelligen.
PPS:
Falls Du übst, vergiss nicht, den allokierten Speicher auch wieder mit delete[] freizugeben.

PPPS: ich habe nicht genau hingesehen:

float* my2DArrayCopy = new float[row * size]; //mit[], nicht mit()

wenn ich versuche ein Mehrdimensionales Array zu kopieren

Das, was du willst, ist aber ein eindimensionales Array:

float* my2DArrayCopy = new float[row * size];

Ein zweidimensionales sähe so aus:

// Erstellen
float** my2DArrayCopy = new float*[row];
for (short i = 0; i < row; i++)
	my2DArrayCopy[i] = new float[size];

// Löschen
for (short i = 0; i < row; i++)
	delete my2DArrayCopy[i];
delete[] my2DArrayCopy;

...Ein zweidimensionales sähe so aus...

Hmm, für mich ist das ein Array aus Zeigern auf eindimensionale Float-Arrays.
Ob ein Array 1, 2 oder n-dimensional ist, ist doch nur eine Sache der Abstraktion. Man kann ohne weiters n Dimensionen auf ein lineares Array abbilden, so wie es der TO tut. Durch die passendere Dimensionierung erhält es dann eben seine N Dimensionen.

Den allokierten Speicher wieder frei zu geben habe ich bedacht

Das war eigentlich nicht zu Übungszwecken gedacht, welche deutlich besseren Möglichkeiten bietet mir den C++ sowas zu bewerkstelligen?

Vielen Dank für die Hilfe!

Hmm, für mich ist das ein Array aus Zeigern auf eindimensionale Float-Arrays.

Ich wüsste nicht, was man in C++ sonst unter einem 2-dimensionalen Array verstehen sollte.

Tachyon schrieb:

Ob ein Array 1, 2 oder n-dimensional ist, ist doch nur eine Sache der Abstraktion. Man kann ohne weiters n Dimensionen auf ein lineares Array abbilden, so wie es der TO tut. Durch die passendere Dimensionierung erhält es dann eben seine N Dimensionen.

Das bestreite ich ja gar nicht, ich will nur nicht, dass Missverständnisse entstehen. Denn das Array des Threaderstellers ist eindimensional, egal was er sich darunter vorstellt

Sharpie schrieb:

Das war eigentlich nicht zu Übungszwecken gedacht, welche deutlich besseren Möglichkeiten bietet mir den C++ sowas zu bewerkstelligen?

In der STL gibt es Container wie z.B. std::vector (Link).

for(size_t i = 0; i != (row * size); ++i)
{
    my2DArrayCopy[i] = my2DArray[i];
}

Dann gibt es noch die STL (Standard Template Library) mit vielen tollen Dingen, wie z.B. Containern und vorgefertigte Algorithmenschablonen für alle mögichen Anwendungsfälle.

Wenn Dein Interface gegeben ist, könnte die Funktion auch wie folgt aussehen:

#include <vector>
#include <algorithm>

void myFunction(float* my2DArray, int row, int size)
{
    std::vector<float> my2DArrayCopy(my2DArray, my2DArray + (row * size));

    //...

    std::copy(my2DArrayCopy.begin(), my2DArrayCopy.end(), my2DArray);
}

Oder besser:

void myFunction(std::vector<float>& input)
{
    std::vector<float> myCopy(input);

    //...

    input = myCopy;
}

Tachyon schrieb:

Hmm, für mich ist das ein Array aus Zeigern auf eindimensionale Float-Arrays.

Ich wüsste nicht, was man in C++ sonst unter einem 2-dimensionalen Array verstehen sollte.

Sowas z.B.:

float a[10][10]  //a != float**, liegt linear im Speicher.

Sowas z.B.:

float a[10][10]  //a != float**, liegt linear im Speicher.

Okay, da hast du Recht. Dynamisch geht's trotzdem nicht anders :p

Aber ich weiss nicht, ob dein Beispiel mit std::copy und Iteratoren den Threadersteller nicht ein wenig überfordert, wenn er noch nicht einmal std::vector kennt... Am Anfang ist es vielleicht besser, nur mit Indizes zu arbeiten. Da ist das Beispiel mit Kopierkonstruktor geeigneter.

@ Sharpie:
Ich würde die Schleifenvariablen i und j in deinem ersten Code lokal (also im Schleifenkopf) deklarieren, du benötigst sie ja sonst nirgendwo.

Tachyon schrieb:

Sowas z.B.:

float a[10][10]  //a != float**, liegt linear im Speicher.

Okay, da hast du Recht. Dynamisch geht's trotzdem nicht anders :p

Dann schau die mal boosts multiarray an.

Vector und co sind mir schon bekannt, vielleicht sollte ich an dieser Stelle mal genauer erklären, was ich vorhabe. Ich benötige das eindimensionale Array, auf dem zwei Dimensionen abgebildet sind in einem

vector< map<string,float> > myMap

Mein Array sieht z.B. so aus, wobei ein Datensatz drei Felder belegt:
12,5,0,30,22,0

Jeder Datensatz soll in eine map gepackt werden:
Datensatz1: myMap["value_a"]=12; myMap["value_b"]=5; myMap["sum"]=0;
Datensatz2: myMap["value_a"]=30; myMap["value_b"]=22; myMap["sum"]=0;

Damit ich zum Schluss einen Vector mit allen Datensätzen habe. Diesen Vektor kann ich dann verarbeiten und anschlißend soll dieser bzw. die Datensätze zurück in das eindimensionale Array geschrieben werden.

Das eindimensionale Array wird deshalb benötigt, weil diese Daten aus einer anderen Software so übergeben werden.

Habt ihr eine Idee wie das ganze besser zu lösen ist?

Dies war nur ein kleines Beispiel mit den drei Werten um die Vorgehensweise zu verdeutlichen, in der Software befinden sich in einer Map ca. 65 Werten.

Sind diese Informationen für potentielle Tipps ausreichend, oder gibt es noch Fragen dazu?

float MyClass::calculate(vector< map<string,float> > myVector)
{	
	int i=0, j=0;
	float fltResult=0;

	//Reihenfolge der Datzensätze bestimmen
	for(i = myVector.size()-1; i>=1; i--)
	{
		for(j=0; j<i; j++)
		{
			if(myVector[j]["value_a"]<myVector[j+1]["value_a"])
			{
				myVector.swap(myVector[j+1],myVector[j]);
			}
		}
	}

	//Anfangswerte ermitteln
	float fltA = getAddition(myVector[0]["value_a"]);
	float fltSum = getAddition(myVector[0]["sum"]);
	float fltDecrease = getDecrease(myVector[0]["decrease"]);

	//Berechnung durchführen
	for (i=1; i<myVector.size(); i++){
		fltDecrease = getDecrease(myVector[i]["decrease"], fltDecrease);

		if(myVector[i]["value_h"]>85){
			fltDecrease = fltDecrease+myVector[i]["value_y"];
			fltSum = fltSum-myVector[i]["value_h"];
		}

		fltResult = fltSum+myVector[i]["value_d"]*(myVector[i]["value_g"]-myVector[i]["value_d"])-fltA;
		fltA = fltA-myVector[i]["value_i"];

		myVector[i]["value_a"] = myVector[i]["value_h"]+(myVector[i]["value_v"]/3)
	}

	return fltResult;
}

struct CalcDataElem
{
    float value_a;
    float value_d;
    float value_g;
    float value_h;
    float value_i;
    float value_v;
    float value_y;
    float decrease;
    float sum;
};

typedef std::vector<CalcDataElem> CalcData;

//...

float MyClass::calculate(CalcData myVector) //original nicht aendern->pass by value
{
    //Funktor sortiert nach value_a
    struct SortBy_value_a
    {
        bool operator()(const CalcDataElem& L, const CalcDataElem& R)
        {   return L.value_a < R.value_a;   }
    } value_aSorter;

    //sortieren
    std::sort(myVector.begin(), myVector.end(), value_aSorter);

    const float SpecialCase = 85.0f;   //Magic Numbers sind Mist! Sprechende Namen benutzen
    const float SpecialDivider = 3.0f; //s.o.

    CalcData::iterator iter = myVector.begin();
    float result           = 0.0f; 
    float currentValueA    = iter->value_a;  //ich weiss nicht, was getAddition tut, daher direkt myVector[0].value_a
    float currentSum       = iter->sum;      //s.o.
    float currentDecrease  = iter->decrease; //s.o. nur fuer getDecrease

    while( iter != myVector.end() )
    {
        currentDecrease = getDecrease(iter->decrease, currentDecrease);
        if(iter->value_h > SpecialCase)
        {
            currentDecrease += iter->value_y;
            currentSum      -= iter->value_h;
        }
        result = currentSum + iter->value_d * (iter->value_g - iter->value_d) - currentValueA;
        currentValueA -= iter->value_i;
        iter->value_a = iter->value_h + (iter->value_v / SpecialDivider);
        ++iter;
    }
    return result;
}

sieht professionell aus und gefällt mir sehr gut. Ich werde es mal so versuchen und gebe dann eine entsprechende Rückmeldung, kann aber ein paar Tage. Vielen Dank aber schon einmal für die Mühe und das tolle Beispiel.

//Funktor sortiert nach value_a
static struct SortBy_value_a
{
	bool operator()(const CalcDataElem& L, const CalcDataElem& R)
	{   return L.value_a < R.value_a;   }
} value_aSorter;

außerhalb der Funktion befinden und mit einem "static" erweitert werden, sonst erhalte ich einen Kompiler-Fehler.

Sonst funktioniert alles bestens und habe einen großen Teil der Software bereits umgestellt, nochmal vielen Dank!

Wenn ich das ganze richtig sehe, muss sich:

//Funktor sortiert nach value_a
static struct SortBy_value_a
{
	bool operator()(const CalcDataElem& L, const CalcDataElem& R)
	{   return L.value_a < R.value_a;   }
} value_aSorter;

außerhalb der Funktion befinden und mit einem "static" erweitert werden, sonst erhalte ich einen Kompiler-Fehler.

Sonst funktioniert alles bestens und habe einen großen Teil der Software bereits umgestellt, nochmal vielen Dank!

Nö, eigentlich darf es in der Funktion stehen. Was sagt der Compiler denn?

Sharpie schrieb:

Wenn ich das ganze richtig sehe, muss sich:

//Funktor sortiert nach value_a
static struct SortBy_value_a
{
	bool operator()(const CalcDataElem& L, const CalcDataElem& R)
	{   return L.value_a < R.value_a;   }
} value_aSorter;

außerhalb der Funktion befinden und mit einem "static" erweitert werden, sonst erhalte ich einen Kompiler-Fehler.

Sonst funktioniert alles bestens und habe einen großen Teil der Software bereits umgestellt, nochmal vielen Dank!

Nö, eigentlich darf es in der Funktion stehen. Was sagt der Compiler denn?

Die Klasse muss außerhalb der Funktion definiert sein.
, denn lokale Klassen dürfen nicht Templateargument sein (und der sort-Aufruf deduziert ja die Klasse aus dem Argument). Wo das Objekt allerdings definiert wird, ist unerheblich. static ist unnötig, im Zweifelsfall wäre ein anonymer Namensraum vorzuziehen. Falls die Funktion calculate allerdings inline im Header definiert ist, und value_aSorter auf Namensraumebene definiert wird, darf es weder static sein, noch sich in einem anonymen Namensraum befinden, sonst wird die ODR verletzt. Am sinnvollsten und üblich dürfte immer noch sein, das Vergleichsobjekt temporär direkt beim sort-Aufruf zu erzeugen.

Die Klasse muss außerhalb der Funktion definiert sein.
, denn lokale Klassen dürfen nicht Templateargument sein (und der sort-Aufruf deduziert ja die Klasse aus dem Argument). Wo das Objekt allerdings definiert wird, ist unerheblich. static ist unnötig, im Zweifelsfall wäre ein anonymer Namensraum vorzuziehen. Falls die Funktion calculate allerdings inline im Header definiert ist, und value_aSorter auf Namensraumebene definiert wird, darf es weder static sein, noch sich in einem anonymen Namensraum befinden, sonst wird die ODR verletzt. Am sinnvollsten und üblich dürfte immer noch sein, das Vergleichsobjekt temporär direkt beim sort-Aufruf zu erzeugen.

Der Typ wird doch nicht aus der Prädikaten-Klasse deduziert, sondern aus dem Iteratoren-Typ.

Der Typ wird doch nicht aus der Prädikaten-Klasse deduziert, sondern aus dem Iteratoren-Typ.

Der Iterator-Typ wird wohl aus dem Iterator deduziert. Der Typ des Prädikats hat aber mit dem Iterator wenig zu tun.

Der Typ wird doch nicht aus der Prädikaten-Klasse deduziert, sondern aus dem Iteratoren-Typ.

template<class RandomAccessIterator, class Compare>
void sort(RandomAccessIterator first, RandomAccessIterator last,
Compare comp);

Tachyon schrieb:

Der Typ wird doch nicht aus der Prädikaten-Klasse deduziert, sondern aus dem Iteratoren-Typ.

template<class RandomAccessIterator, class Compare>
void sort(RandomAccessIterator first, RandomAccessIterator last,
Compare comp);

Jo, habs auch gerade unter 14.3.1 §2 gefunden. Und Comeau und g++ schlucken das auch einleuchtenderweise tatsächlich nicht.
MSVC 2008 allerdings schon...