Ich hab zur Zeit ein Brett vor dem Kopf:

Deklariert in myprogdlg.h:

CString m_strtext[30000][4]; // Array 
CDlg_Dialog m_dlgDialog;  // Dialogfeld welches später modal aufgerufen wird

in dialogdlg.h

CString m_strdlgtext[30000][4];

Jetzt möchte ich das Array an das Array aus dem Dialog
übergeben:

m_dlgDialog.m_strdlgtext = &m_strtext;

bekomme aber den Fehler :
error C2440: '=': 'CString (*_w64 )[30000][4]' kann nicht in 'CString[30000][4]' konvertiert werden

Ich steh jedesmal mit diesen Array-Pointern auf Kriegfuß.
'jaja ich weiss , eigentlich ganz einfach'

Aber vielleicht kann mir ja jemand weiterhelfen ?

Danke im Voraus und Gruß
Linus

error C2106: '=' Linker Operand muss ein L-Wert sein

int a=5;
int b=a;

Oder willst Du m_strdlgtext als Zeiger (Pointer) auf m_strtext zeigen lassen, so daß die Daten letztendlich nur einmal vorhanden sind, aber von zwei Variablen aus bearbeitet werden können? So wie in:

int a=5;
int *b=&a;

Wenn Du ersteres machen willst (Kopie), dann geht das ganz einfach. Felder lassen sich auf diese Weise nicht kopieren, also mußt Du jedes Element einzeln übertragen:

for (int i=0; i<30000; i++)
    for (int k=0; k<4; k++)
        m_dlgDialog.m_strdlgtext [i] [k]=m_strtext [i] [k];

Willst Du allerdings zweiteres (Zeiger zeigt auf Feld) machen, dann ist das Problem folgendes: Wenn Du

CString m_strdlgtext[30000][4];

deklarierst, dann reserviert das Programm bereits Speicher für den Inhalt des Feldes. Dann kannst Du den Variablennamen nicht mehr zeigermäßig auf ein anderes Feld zeigen lassen. Also

int b [10];

ist nicht das gleiche wie

int *b;

Das heißt: Sowas hier funktioniert zwar:

int a [10];
int *b=&a;

aber sowas nicht:

int a [10];
int b [10]=&a;

Die Lösung lautet in dem Fall also folgendermaßen: Du mußt m_strdlgtext als Zeiger deklarieren:

CString *m_strdlgtext;

und dann kannst Du schreiben

m_dlgDialog.m_strdlgtext=&m_strtext;

Ich hoffe, ich konnte Dir helfen.

Die Lösung lautet in dem Fall also folgendermaßen: Du mußt m_strdlgtext als Zeiger deklarieren:

CString *m_strdlgtext;

und dann kannst Du schreiben

m_dlgDialog.m_strdlgtext=&m_strtext;

Ich hoffe, ich konnte Dir helfen.

Du hast recht aber es tut mir leid , habe ich auch ausprobiert , geht aber
glaube ich nur mit eindimensionalen arrays

So muss ja auch bei der übergabe eines zweidimensionalen Arrays
an eine Funktion immer der zweite Wert mit übergeben bzw deklariert werden
(wenn ich mich richtig erinnere, ist schon so lange her)

in diesem fall kommt aber der fehler:
error C2440: '=': 'CString (*_w64 )[30000][4]' kann nicht in 'CString*' konvertiert werden

driving mad

Aber war es bei solchen Arrays nicht der Fall, dass wenn man einen Zeiger auf so ein Array übergibt, es der Zeiger des ersten Objekt ist. Also z.b. bei einem eindimensionalen Array:

CString Str[30000];
CString* pStr;

pStr = &Str;
// Ist das gleiche wie:
pStr = &Str[0];

Anderst gesagt wäre es in einem zwei dimensionale Array:

CString Str[30000][4];
CString* pStr;

pStr = &Str[0][0];

Kann sein, dass ich gerade völligen Scheiss erzähle, ist schon etwas länger her, dass ich diese Sorte von Arrays verwendet habe. Die sind mir einfach immer zu statisch, deshalb brauche ich meistens CArray oder sowas ...
Grüssli

Anderst gesagt wäre es in einem zwei dimensionale Array:

CString Str[30000][4];
CString* pStr;

pStr = &Str[0][0];

Dann kann ich aber pStr[i][j] nicht referenzieren ,

Zuerst einmal möchte ich mich korrigieren: Meine beiden Codezeilen

CString *m_strdlgtext;
m_dlgDialog.m_strdlgtext=&m_strtext;

müßten eigentlich so lauten:

CString *m_strdlgtext;
m_dlgDialog.m_strdlgtext=m_strtext;

weil ja m_strtext (ohne Indexangabe) auch schon ein Zeiger ist.

Daß das mit zweidimensionalen Feldern nicht klappt, hab ich auch erst heute rausgefunden. Ich weiß da leider keine Lösung, außer daß Du aus dem zweidimensionalen vielleicht ein eindimensionales Feld machst.

An Dravere:

Aber war es bei solchen Arrays nicht der Fall, dass wenn man einen Zeiger auf so ein Array übergibt, es der Zeiger des ersten Objekt ist.

Ganz genau. Der Feldname ohne Indexangabe ist eigentlich nichts weiter als ein Zeiger auf das erste Element. Dein Code hat allerdings noch einen kleinen Fehler. Er müßte so lauten:

CString Str[30000]; 
CString* pStr; 
pStr = Str; //Hier keine Adresszuweisung. (Das ist der gleiche Fehler, den ich in meinem ersten Post gemacht habe.)
// Ist das gleiche wie: 
pStr = &Str[0];

Die Kurzfassung lautet also:

feld==&feld [0]

Leider funktioniert das aus irgendeinem Grund nicht mit zweidimensionalen Feldern.

Man kann übrigens mit einem Zeiger wie in einem Feld arbeiten, selbst wenn der Zeiger gar nicht auf ein Feld zeigt.

int a=5;
int *b=&a;
cout<<b [7];

gibt keinen Kompilierfehler, nur ein etwas merkwürdiges Ergebnis.

An CStoll:

Du brauchst einen Pointer auf ein entsprechend großes CString-Array (also CString* m_str[30000][4]=&str;). Alternativ müsstest du alle Elemente des gegebenen Arrays einzeln kopieren

Wenn es ums Kopieren geht, dann ist es ja klar: Man erstellt das zweite (noch leere) Feld und kopiert per Wiederholung mit Zähler alles rein. Aber wenn es nur um Referenz geht, funktioniert Deine Version (Zeiger auf ein entsprechendes Feld) leider nicht (was ja auch verständlich ist, die Variable speichert ohnehin nur die Anfangsadresse und da ist es völlig egal, ob man in der Zeigerdeklaration noch hinterschreibt, wieviele Einträge das Quellfeld hat).

Zum Abschluß noch die Erklärung, warum man zwar einen fremden Zeiger auf ein eindimensionales Feld referenzieren lassen kann, das aber bei einem zweidimensionalen nicht klappt (falls es jemanden interessiert):
Wenn ich in einem eindimensionalen Feld den Index angebe, braucht das Programm ab der Anfangsadresse nur soundsoviel Schritte nach vorne zu laufen. Der Zeiger muß den Inhalt und die Größe des Feldes nicht kennen, um das zu realisieren.

|
XXXXXXXXXX

Bei Feld [3] geht er also einfach drei Schritte nach vorn:

|
XXXXXXXXXX

Aber bei einem zweidimensionalen Feld ist das schon schwieriger:

XXXXXX
XXXXXX
XXXXXX

ist ja im Speicher auch nur in der Form

XXXXXXXXXXXXXXXXXX

abgespeichert. Wenn ich jetzt Feld [2] [1] sage, tja, wie weit soll er gehen? Er müßte die ersten zwei Zeilen überspringen und in der dritten einen Schritt nach vorne gehen. Aber er weiß nicht, wo eine Zeile aufhört und die nächste anfängt. Das vorliegende Feld [6] [3] könnte genausogut [9] [2] lauten. Also kann man einen simplen Zeiger nicht auf ein externes zweidimensionales Feld zeigen lassen. (Und deshalb muß man bei Funktionsparametern solcher Art auch mindestens einen der Indizes angeben, damit sich das Programm beim Zugriff zurechtfindet.)

CString str[3000][4];
CString* pstr[4];//Pointer auf 4er Array(s)

pstr = str;

CString m_strtext[30000][4];

hast und auf dieses mit Hilfe eines Zeigers zugreifen willst (also ohne es zu kopieren), dann machst Du das so:

CString (*m_strdlgtext) [4];
m_dlgDialog.m_strdlgtext=m_strtext;

Und zugreifen tust Du auf die einzelnen Einträge wie mit der ursprünglichen Variable:

m_strtext[534][2]
//liefert genauso den entsprechenden Wert, wie
m_strdlgtext[534][2]