Ich arbeite mich derzeit in ein Projekt ein und habe bisher nur geringe Programiererfahrung in C++, aber zumindest ein Grundwissen ist doch schon vorhanden.
Beim "Verstehen versuchen" hänge ich derzeit an folgender Stelle im Code, weil mir einige Elemente darin NEU sind:

entryArray = new double[nVectorElements];
for(int i=0; i<nVectorElements; i++)
{
    *((double*)entryArray+i) = *((double*)aVector+i);
}

Was passiert hier?

• Ist entryArray ein ganz normales Array mit [nVectorElements] Feldern?
  Warum wird es nicht "ganz normal" deklariert? Etwa so:

double entryArray[nVectorElements];

• Was macht der *(...) -Operator?
• Was macht der (double*)... -Operator?
• Was passiert durch das +i ?
  Wird damit raufgezählt (Wie bei entryArray[0 + i] )?

Kurze Erläuterung:
aVector ist ein bekannter Vektor mit nVectorElements Elementen.

Ich hoffe die Frage ist präzise genau gestellt. Falls irgendetwas unklar ist, fragt einfach nach, dann versuch ich das besser zu formulieren!

Vielen Dank schonmal für eure Hilfe

entryArray = new double[nVectorElements];
for(int i=0; i<nVectorElements; i++)
{
    *((double*)entryArray+i) = *((double*)aVector+i);
}

entryArray ist schon ein Zeiger auf double, damit ist der erste cast Unfug.

entryArray = new double[nVectorElements];
for(int i=0; i<nVectorElements; i++)
{
    *((double*)entryArray+i) = *(aVector+i);
}

Dann ist a[b] eine Schreibabkürzung für *(a+b), also

entryArray = new double[nVectorElements];
for(int i=0; i<nVectorElements; i++)
{
    *((double*)entryArray+i) = aVector[i];
}

Auch auf der anderen Seite

entryArray = new double[nVectorElements];
for(int i=0; i<nVectorElements; i++)
{
    *(entryArray+i) = aVector[i];
}

entryArray = new double[nVectorElements];
for(int i=0; i<nVectorElements; i++)
{
    aVector[i] = aVector[i];
}

Oder einfach

entryArray = new double[nVectorElements];

Hoffe, das ist nicht im beruflichen Kontext passiert.

Was passiert hier?
[list][*]Ist entryArray ein ganz normales Array mit [nVectorElements] Feldern?
Warum wird es nicht "ganz normal" deklariert? Etwa so:

double entryArray[nVectorElements];

Geht nicht, wenn nVectorElements nicht zur Compileteit bekannt ist, oder wenn nVectorElements sehr groß (sagen wir mal über 250000) ist.

Hab(n)ichts schrieb:

[*]Was macht der *(...) -Operator?

*(bla) macht Zugriff auf dahin, wo der Zeiger (bla) hinzeigt. Das Array bla ist gar kein Array, sondern ein Zeiger aufs erste Element. Mit bla+i geht die Adresse i Stellen weiter, man beachte, nicht i Bytes, sondern i mal sizeof(*double) bytes! Mystische Zeigerarithmetik von C. Allgemein schreibt man auch i mal sizeof(*bla) bytes. *bla ist ja das erste Element von bla, ein double.

Hab(n)ichts schrieb:

[*]Was macht der (double*)... -Operator?

Casten.

char test[8];//8 Bytes
double* t2=test;//geht nicht
double* t3=(double*)test;//geht
*t3=3.14;

//oder zusammen
char test[8];//8 Bytes
*(double*)test=3.14;//geht

Hab(n)ichts schrieb:

[*]Was passiert durch das +i ?
Wird damit raufgezählt (Wie bei entryArray[0 + i] )?

Ganz genau.
entryArray[0+i]
ist
entryArray[i]
ist
*(entryArray+i)
ist
*(i+entryArray)
ist
i[entryArray]
ist
(i+0)[entryArray]
ist
i[entryArray+0]

Der Operator[] macht einfach aus a[b] ein *(a+b). Das Array ist hier gar kein Array, sondenr ein Zeiger aufs erste Element.

entryArray ist schon ein Zeiger auf double, damit ist der erste cast Unfug.

entryArray könnte vom Typ void* sein. Oder wäre dann ein Cast bei new double[...] notwenidg gewesen?

Beim "Verstehen versuchen" hänge ich derzeit an folgender Stelle im Code, weil mir einige Elemente darin NEU sind:

entryArray = new double[nVectorElements];
for(int i=0; i<nVectorElements; i++)
{
    *((double*)entryArray+i) = *((double*)aVector+i);
}

Scheußlich ist das.
*((double*)entryArray+i)
hätte man auch einfach als
entryArray[i]
schreiben können!

Unnötig kompliziert, unnötig new[] verwendet.

Du willst C++ lernen und dann auch verstehen, was der Kram hier soll. Verständlich. Ich möchte nur nochmal betonen, dass das hier kein Positivbeispiel ist. Also:

(double*)entryArray
ist ein C-style cast. Hier wird aus entryArray , was ein Zeiger auf double ist, ein Zeiger auf double gemacht. Also eigentlich eine sinnlose Aktion, weil entryArray schon ein Zeiger auf double ist.

zeiger+i
Das hier ist Zeigerarithmetik. Der Zeiger wird um i Elemente erhöht. Wenn der Zeiger "zeiger" auf das erste Element eines Arrays zeigt, dann zeigt zeiger+i auf das (i+1)-te Element des Arrays

*zeiger
Das hier ist eine Dereferenzierung.

Hab(n)ichts schrieb:

Ist entryArray ein ganz normales Array mit [nVectorElements] Feldern?

Nein. Es ist ein Zeiger auf das erste Element eines Arrays mit nVectorElements Elementen.

Hab(n)ichts schrieb:

Warum wird es nicht "ganz normal" deklariert? Etwa so:

double entryArray[nVectorElements];

Das kann man nicht ohne Kontext beantworten. Eine "warum nicht so?"-Frage führt hier ggf auch zu nichts; denn der Autor war offensichtlich nicht besonders kompetent.

... für die schon jetzt zahlreichen und (mit etwas "sacken lassen") auch sicher hilfreichen Antworten.
Jetzt hab ich doch schon beim kurz drüberfliegen ein bisschen mehr kapiert.
Werd mir das heute Nachmittag nochmal zu Gemüte führen

LG

Jetzt weiß ich auch wonach ich hätte suchen müssen!
Das mit dem casten wird übrigens auch gemacht, weil
aVector als void* -Zeiger deklariert wurde!

LG