Mehrdimensionales Array kopieren

Nexus

Sharpie schrieb:

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;

Tachyon

Nexus schrieb:

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

Sharpie

Das übergebene Array ist nicht zu klein mit den eckigen Klammern funktioniert es jetzt!

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!

Nexus

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.

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

Tachyon

Also:
Erstmal ist Dein Array ja nur ein eindimensionales Array, auf das Du zwei Dimensionen abbildest. Das kopieren kann also erstmal mit normales Sprachelementen auch so gelöst werden:

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

Nexus schrieb:

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.

Nexus

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

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.

camper

Nexus schrieb:

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.

Sharpie

Noch einmal vielen Dank für die tollen Tipps und die Beteiligung an diesem Beitrag.

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?

Tachyon

Für potentielle Tips würden noch ein paar Infos bezüglich der geplanten Verarbeitung hilfreich sein. Was genau soll denn mit dem vector<map<string,float> > gemacht werden?
Wieso packst Du die Daten noch einmal extra in eine Map? Wenn es pro Vektor-Element immer drei gleiche Elemente mit gleichem Key sind, muss das nicht unbedingt sein.

Sharpie

Für jeden Datensatz also eine Map wird eine Berechnung durchgeführt. Wobei über die Feldbezeichnung also den Key(String) auf den entsprechenden Wert zugegriffen wird.

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?

Tachyon

Kannst Du vielleicht mal ein Codeschnippsel für die Berechnung posten?

Sharpie

Klar kann ich ein Beispiel Posten, aber nur sehr stark vereinfacht. Da steht jetzt keine besondere Logik dahinter, es ist viel mehr eine grobe Struktur der Berechnung, also bitte nicht so sonderlich auf die Keys in der Map oder ähnliches achten. Ich hoffe das Hilft weiter, wenn nicht gebe ich gerne weitere Auskünfte 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;
}

Tachyon

Also, ich würde auf die Map verzichten, und es vielleicht eher so machen:

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;
}

Sharpie

Hallo Tachyon,

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.

Sharpie

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!

Tachyon

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?

camper

Tachyon schrieb:

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.

Tachyon

camper schrieb:

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.

LordJaxom

Tachyon schrieb:

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.