4. zu blöd für Pointer ?

zu blöd für Pointer ?

  • L

    habe ich zuerst auch gedacht dann kommt aber :

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

    0
  • N

    O.k., zuerst müßte man wissen, was Du genau machen willst: Willst Du das Stringfeld direkt kopieren, so daß m_strdlgtext sämtliche Werte noch einmal beinhaltet, welche Du dann unabhängig von m_strtext behandeln kannst? Ein analoges Simpelbeispiel wäre dann das hier:

    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.

    0
  • L

    NES-Spieler schrieb:

    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

    0
  • Administrator

    Alles ohne Gewähr:

    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

    0
  • L

    Dravere schrieb:

    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 ,

    😕

    0
  • C

    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

    0
  • N

    An linus:

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

    0
  • C

    Bei zweidimensionalen Feldern funktioniert es genauso wie mit eindimesionalen - nur daß die Umwandlung Array=Pointer nur in der äußersten Dimension klappt. Das heißt, du kannst dein 2D Array nur in einen "Pointer auf Array" übergeben:

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

pstr = str;
    0
  • N

    An CStoll:
    Und ich sage Dir, so funktioniert es nicht. Das gibt einen Fehler.

    0
  • N

    O.k., ich hab die Lösung. Wenn Du ein Feld

    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]
    0
Anmelden zum Antworten