[ Hypercell ein ] [ Hypercell aus ] [ Zeige Navigation ] [ Verstecke Navigation ]
c++.de  
   
Forentreff 2012   [ Startseite ] [ Links ] [ FAQs ] [ Humor ] [ Compiler ] [ Bücher ] [ Magazin ] [ Tutorials ] [ Videos ] [ Impressum & AGB ] [ Twitter Twitter ] [ Facebook Facebook ] [ Kontakt ]
[ Anleitung ] [ Suchen ] [ Profil ] [ Eigene Beiträge ] [ Registrieren ]
[ Login ]
   
Bücher-Shop mit Amazon (Buchkategorien):  C++ : Referenzen zu C++ : C++ Builder : Visual C++ : C# : Java : Spieleprogrammierung : Systemprogrammierung Linux : Software-Entwicklung : .NET : Compilertechnik : Algorithmen & Datenstrukturen : Objektorientierung : Entwurfsmuster : UML : eXtreme Programming : Scrum : Projektmanagement : Software-Testing : Datenbanken : Tom DeMarco : Dilbert : User Friendly
C/C++ Forum :: Assembler ::  String Array  
Gehen Sie zu Seite Zurück  1, 2   Zeige alle Beiträge auf einer Seite 		Auf Beitrag antworten
Autor Nachricht
masm
Unregistrierter
Beitrag masm Unregistrierter 19:21:37 26.12.2011   Titel:              Zitieren
GutenAbend schrieb:
Bin nur etwas von den masm32 Macros abgewichen, dh. ich hab z.B. anstatt "alloc(...)" -> VirtualAlloc bzw HeapAlloc verwendet.

Ist richtig so, HeapAlloc sollte man verwenden – alloc() liest sich in Beispiel halt besser ;-)

GutenAbend schrieb:
Wenn ich nun die Elemente aus dem dynamischen Array ausgeben will, werden die mir falsch herum ausgegeben, d.h. LIFO.
Kann man natürlich leicht umgehen, aber woran liegt das ?

Das liegt daran, wie du die Strings ein- und/oder ausgibst.

GutenAbend schrieb:
Noch etwas:
Rein von der Performance wäre es doch sinnvoller, einen großen Block zu reservieren (und ggf. später noch vergrößern), anstatt für jedes Element neuen Speicher zu reservieren, oder sehe ich das falsch?

ja, das ist Sinnvoll und deswegen macht es der Heap-Manager für dich.
GutenAbend
Unregistrierter
Beitrag GutenAbend Unregistrierter 03:13:37 27.12.2011   Titel:              Zitieren
Hm...alles klar soweit, bis auf die Kleinigkeit mit der verkehrten Ausgabe.
Ich baue das Array doch folgendermaßen zusammen:

-Str1
-Str1+Str2
-Str1+Str2+Str3
...

Ausgabe:
-[Array]
-[Array+1] <- bzw. + 4
-[Array+2]
...

Aber warum ist jetzt die Ausgabe LIFO?

Gruß
masm
Unregistrierter
Beitrag masm Unregistrierter 16:05:31 27.12.2011   Titel:              Zitieren
zeig doch einfach den code.
GutenAbend
Unregistrierter
Beitrag GutenAbend Unregistrierter 17:57:31 27.12.2011   Titel:              Zitieren
Aber nicht für das ganze Durcheinander erschlagen ;)

Assembler Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
.DATA
    str1        DB        "str1',0
    str2        DB        "str222',0
    str3        DB        "str3333333',0
.DATA?
    pStrDyn        DD        3 DUP(?)
.CODE
WinMainCRTStartup PROC
    LOCAL pStr:DWORD
   
    lea        ESI, pStrDyn
    xor        EBX, EBX
   
.while EBX < 3

    cmp        EBX, 1
    je        Load2
    jb        Load3
Load1:
    mov        pStr, 0
    mov        pStr, OFFSET str1
    jmp        Done
Load2:
    mov        pStr, 0
    mov        pStr, OFFSET str2
    jmp        Done
Load3:
    mov        pStr, 0
    mov        pStr, OFFSET str3
Done:

    invoke            eStrLen, pStr
    mov        EDX, EAX
    inc        EDX

    ;push            PAGE_EXECUTE_READWRITE
    ;mov        EAX, MEM_COMMIT
    ;or        EAX, MEM_RESERVE
    ;push            EAX
    ;push            EDX
    ;push            0
    ;call            VirtualAlloc

    call            GetProcessHeap
    push            EDX
    push            HEAP_ZERO_MEMORY
    push            EAX
    call            HeapAlloc
    mov        EDI, EAX

    invoke            szCopy, pStr, EDI

    mov        DWORD ptr [ESI+EBX*4], EDI
    inc        EBX

.endw
    ;----------------------------------------------
    lea        ESI, pStrDyn
    mov        EBX, 3

GO:
    dec        EBX
    push            0
    mov        EAX, DWORD ptr [ESI+EBX*4]
    push            EAX
    push            EAX
    push            0
    call            MessageBoxA

    cmp        EBX, 0
    jne        GO

    push            0
    call            ExitProcess
    ret
WinMainCRTStartup ENDP
...
Assembler Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
.DATA
str1 DB "str1',0
str2 DB "str222',0
str3 DB "str3333333',0
.DATA?
pStrDyn DD 3 DUP(?)
.CODE
WinMainCRTStartup PROC
LOCAL pStr:DWORD

lea ESI, pStrDyn
xor EBX, EBX

.while EBX < 3

cmp EBX, 1
je Load2
jb Load3
Load1:
mov pStr, 0
mov pStr, OFFSET str1
jmp Done
Load2:
mov pStr, 0
mov pStr, OFFSET str2
jmp Done
Load3:
mov pStr, 0
mov pStr, OFFSET str3
Done:

invoke eStrLen, pStr
mov EDX, EAX
inc EDX

;push PAGE_EXECUTE_READWRITE
;mov EAX, MEM_COMMIT
;or EAX, MEM_RESERVE
;push EAX
;push EDX
;push 0
;call VirtualAlloc

call GetProcessHeap
push EDX
push HEAP_ZERO_MEMORY
push EAX
call HeapAlloc
mov EDI, EAX

invoke szCopy, pStr, EDI

mov DWORD ptr [ESI+EBX*4], EDI
inc EBX

.endw
;----------------------------------------------
lea ESI, pStrDyn
mov EBX, 3

GO:
dec EBX
push 0
mov EAX, DWORD ptr [ESI+EBX*4]
push EAX
push EAX
push 0
call MessageBoxA

cmp EBX, 0
jne GO

push 0
call ExitProcess
ret
WinMainCRTStartup ENDP
...
Assembler Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
.DATA
    str1        DB        "str1',0
    str2        DB        "str222',0
    str3        DB        "str3333333',0
.DATA?
    pStrDyn        DD        3 DUP(?)
.CODE
WinMainCRTStartup PROC
    LOCAL pStr:DWORD
   
    lea        ESI, pStrDyn
    xor        EBX, EBX
   
.while EBX < 3

    cmp        EBX, 1
    je        Load2
    jb        Load3
Load1:
    mov        pStr, 0
    mov        pStr, OFFSET str1
    jmp        Done
Load2:
    mov        pStr, 0
    mov        pStr, OFFSET str2
    jmp        Done
Load3:
    mov        pStr, 0
    mov        pStr, OFFSET str3
Done:

    invoke            eStrLen, pStr
    mov        EDX, EAX
    inc        EDX

    ;push            PAGE_EXECUTE_READWRITE
    ;mov        EAX, MEM_COMMIT
    ;or        EAX, MEM_RESERVE
    ;push            EAX
    ;push            EDX
    ;push            0
    ;call            VirtualAlloc

    call            GetProcessHeap
    push            EDX
    push            HEAP_ZERO_MEMORY
    push            EAX
    call            HeapAlloc
    mov        EDI, EAX

    invoke            szCopy, pStr, EDI

    mov        DWORD ptr [ESI+EBX*4], EDI
    inc        EBX

.endw
    ;----------------------------------------------
    lea        ESI, pStrDyn
    mov        EBX, 3

GO:
    dec        EBX
    push            0
    mov        EAX, DWORD ptr [ESI+EBX*4]
    push            EAX
    push            EAX
    push            0
    call            MessageBoxA

    cmp        EBX, 0
    jne        GO

    push            0
    call            ExitProcess
    ret
WinMainCRTStartup ENDP
...


Das ist es. Wie gesagt, öfters "hin und her geschoben", von daher... :D
masm
Unregistrierter
Beitrag masm Unregistrierter 21:38:45 27.12.2011   Titel:              Zitieren
Vergleich mal deine Schleifen - der unterschied sollte dir auffallen.
Ganz wichtig: Die Register EAX,ECX und EDX werden durch WinAPI-Funktionen geändert - nur ESI,EDI und EBX bleiben unberührt (Win/Intel ABI). Wenn der Inhalt dieser Register gebraucht wird, musst du sie vor einem API-Aufruf z.B. auf dem Stack oder in einer lokalen Variablen sichern (EDX->Zeile 33-45)
GutenAbend
Unregistrierter
Beitrag GutenAbend Unregistrierter 02:46:15 28.12.2011   Titel:              Zitieren
Oh verdammt!
Nein sorry, das ist meine "optimierte" Methode. So wird alles korrekt ausgegeben...
Wenn ich diese Schleife "korrigiere", tritt eben dieser falsche Effekt auf...
abc.w
Mitglied

Benutzerprofil
Anmeldungsdatum: 25.04.2008
Beiträge: 1364
Beitrag abc.w Mitglied 11:49:48 28.12.2011   Titel:              Zitieren
GutenAbend schrieb:
Oh verdammt!
Nein sorry, das ist meine "optimierte" Methode. So wird alles korrekt ausgegeben...
Wenn ich diese Schleife "korrigiere", tritt eben dieser falsche Effekt auf...

So lange Du keinen Testcode hast, kannst "optimieren" bis zum Umfallen. Danach kann man den Quellcode ausdrucken und als Klopapier benutzen - ehrlich.

_________________
E = int * char^2
GutenAbend
Unregistrierter
Beitrag GutenAbend Unregistrierter 17:08:25 28.12.2011   Titel:              Zitieren
Man beachte die `"` ;)
Optimiert war das falsche Wort, "korrigiert" wäre richtig.

@masm:
Das ist die korrekte Schleife die du meinst. Aber hier tritt eben der Effekt auf, das zu erst das letzte Element ausgegeben wird:

Assembler Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
... ; alles wie oben
    ;----------------------------------------------
    lea        ESI, pStrDyn
    xor        EBX, EBX

.while EBX < 3
    push    0
    mov        EAX, DWORD ptr [ESI+EBX*4]
    push    EAX
    push    EAX
    push    0
    call    MessageBoxA
    inc        EBX
.endw

    push    0
    call    ExitProcess
    ret
WinMainCRTStartup ENDP
...
Assembler Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
... ; alles wie oben
;----------------------------------------------
lea ESI, pStrDyn
xor EBX, EBX

.while EBX < 3
push 0
mov EAX, DWORD ptr [ESI+EBX*4]
push EAX
push EAX
push 0
call MessageBoxA
inc EBX
.endw

push 0
call ExitProcess
ret
WinMainCRTStartup ENDP
...
Assembler Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
... ; alles wie oben
    ;----------------------------------------------
    lea        ESI, pStrDyn
    xor        EBX, EBX

.while EBX < 3
    push    0
    mov        EAX, DWORD ptr [ESI+EBX*4]
    push    EAX
    push    EAX
    push    0
    call    MessageBoxA
    inc        EBX
.endw

    push    0
    call    ExitProcess
    ret
WinMainCRTStartup ENDP
...
masm
Unregistrierter
Beitrag masm Unregistrierter 20:31:24 28.12.2011   Titel:              Zitieren
Code:
    cmp        EBX, 1
    je        Load2
    jb        Load3
Code:
cmp EBX, 1
je Load2
jb Load3
Code:
    cmp        EBX, 1
    je        Load2
    jb        Load3
:warning:
GutenAbend
Unregistrierter
Beitrag GutenAbend Unregistrierter 20:38:38 28.12.2011   Titel:              Zitieren
Wo ist der Smilie, der den Kopf gegen die Wand schlägt?
Danke...
C/C++ Forum :: Assembler ::  String Array  
Gehen Sie zu Seite Zurück  1, 2		 Auf Beitrag antworten

Zeige alle Beiträge auf einer Seite




Nächstes Thema anzeigen
Vorheriges Thema anzeigen
Sie können Beiträge in dieses Forum schreiben.
Sie können auf Beiträge in diesem Forum antworten.
Sie können Ihre Beiträge in diesem Forum nicht bearbeiten.
Sie können Ihre Beiträge in diesem Forum nicht löschen.
Sie können an Umfragen in diesem Forum nicht mitmachen.

Powered by phpBB © 2001, 2002 phpBB Group :: FI Theme

c++.de ist Teilnehmer des Partnerprogramms von Amazon Europe S.à.r.l. und Partner des Werbeprogramms, das zur Bereitstellung eines Mediums für Websites konzipiert wurde, mittels dessen durch die Platzierung von Werbeanzeigen und Links zu amazon.de Werbekostenerstattung verdient werden kann.

Die Vervielfältigung der auf den Seiten www.c-plusplus.de, www.c-plusplus.info, www.c-sar.de, www.c-plusplus.net und www.baeckmann.de enthaltenen Informationen ohne eine schriftliche Genehmigung des Seitenbetreibers ist untersagt (vgl. §4 Urheberrechtsgesetz). Die Nutzung und Änderung der vorgestellten Strukturen und Verfahren in privaten und kommerziellen Softwareanwendungen ist ausdrücklich erlaubt, soweit keine Rechte Dritter verletzt werden. Der Seitenbetreiber übernimmt keine Gewähr für die Funktion einzelner Beiträge oder Programmfragmente, insbesondere übernimmt er keine Haftung für eventuelle aus dem Gebrauch entstehenden Folgeschäden.