[ 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     Zeige alle Beiträge auf einer Seite Auf Beitrag antworten
Autor Nachricht
GutenAbend
Unregistrierter
Beitrag GutenAbend Unregistrierter 19:20:25 25.12.2011   Titel:   String Array            Zitieren
Guten Abend zusammen,

ich möchte, wie die Überschrift schon sagt, ein Array aus mehreren Strings(DateiPfade) erstellen:

- C:\Whatever.exe
- C:\Whatever1.exe
- C:\Whatever2.exe
...

Allerdings hab ich keine Ahnung, wie ich das realisieren soll.
Mein erster Gedanke war, einfach per "DUB" Speicher zu reservieren und dann einen String nach dem anderen dort plazieren.
Das Problem ist aber, dass die Strings nicht gleich lang sind, dh. ich kann sie nicht ansprechen mit Array + 4, etc.
Ich hoffe ihr wisst was ich meine?

Schöne Grüße
masm
Unregistrierter
Beitrag masm Unregistrierter 19:48:29 25.12.2011   Titel:              Zitieren
ein bisschen mehr Information könnten hilfreich ein :xmas1:
GutenAbend
Unregistrierter
Beitrag GutenAbend Unregistrierter 20:23:16 25.12.2011   Titel:              Zitieren
Sry

Windows 7 x64
masm32
Anfänger :)
masm
Unregistrierter
Beitrag masm Unregistrierter 21:41:05 25.12.2011   Titel:              Zitieren
C/C++ 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
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
include \masm32\include\masm32rt.inc
.data
    str1    db "Hello World",0
    str2    db "123",0
    str3    db "456",0
    align 4
    ; string array (= pointer array)
    pStrStatic    PCHAR  str1,str2,str3
.data?
    ; string array (= pointer array)
    pStrDyn    PCHAR 3 dup (?)
.code
main proc
LOCAL pStr:PCHAR

    ; ausgabe des statischen arrays
    lea esi,pStrStatic
    xor ebx,ebx
    .while ebx < LENGTHOF pStrStatic
        ; printf(pStrStatic[i],"\n")
        print PCHAR ptr [esi+ebx*4],13,10
        lea ebx,[ebx+1]
    .endw
   
    ; dynamisch: array einlesen
    lea esi,pStrDyn
    xor ebx,ebx
    .while ebx < LENGTHOF pStrDyn
        ; string einlesen
        mov pStr,input("string: ")
       
        ; string allozieren
        mov edx,len(pStr)
        inc edx
        mov edi,alloc(edx)
       
        ; string kopieren
        invoke szCopy,pStr,edi

        ; pointer speichern
        mov PCHAR ptr [esi+ebx*4],edi
        lea ebx,[ebx+1]
    .endw
   
    ; ausgabe des dynamischen arrays
    lea esi,pStrDyn
    xor ebx,ebx
    .while ebx < LENGTHOF pStrDyn
        print PCHAR ptr [esi+ebx*4],13,10
        ; gib Speicher frei
        free PCHAR ptr [esi+ebx*4]
        lea ebx,[ebx+1]
    .endw
   
    inkey
    exit
main endp
end main
C/C++ 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
include \masm32\include\masm32rt.inc
.data
str1 db "Hello World",0
str2 db "123",0
str3 db "456",0
align 4
; string array (= pointer array)
pStrStatic PCHAR str1,str2,str3
.data?
; string array (= pointer array)
pStrDyn PCHAR 3 dup (?)
.code
main proc
LOCAL pStr:PCHAR

; ausgabe des statischen arrays
lea esi,pStrStatic
xor ebx,ebx
.while ebx < LENGTHOF pStrStatic
; printf(pStrStatic[i],"\n")
print PCHAR ptr [esi+ebx*4],13,10
lea ebx,[ebx+1]
.endw

; dynamisch: array einlesen
lea esi,pStrDyn
xor ebx,ebx
.while ebx < LENGTHOF pStrDyn
; string einlesen
mov pStr,input("string: ")

; string allozieren
mov edx,len(pStr)
inc edx
mov edi,alloc(edx)

; string kopieren
invoke szCopy,pStr,edi

; pointer speichern
mov PCHAR ptr [esi+ebx*4],edi
lea ebx,[ebx+1]
.endw

; ausgabe des dynamischen arrays
lea esi,pStrDyn
xor ebx,ebx
.while ebx < LENGTHOF pStrDyn
print PCHAR ptr [esi+ebx*4],13,10
; gib Speicher frei
free PCHAR ptr [esi+ebx*4]
lea ebx,[ebx+1]
.endw

inkey
exit
main endp
end main
C/C++ 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
include \masm32\include\masm32rt.inc
.data
    str1    db "Hello World",0
    str2    db "123",0
    str3    db "456",0
    align 4
    ; string array (= pointer array)
    pStrStatic    PCHAR  str1,str2,str3
.data?
    ; string array (= pointer array)
    pStrDyn    PCHAR 3 dup (?)
.code
main proc
LOCAL pStr:PCHAR

    ; ausgabe des statischen arrays
    lea esi,pStrStatic
    xor ebx,ebx
    .while ebx < LENGTHOF pStrStatic
        ; printf(pStrStatic[i],"\n")
        print PCHAR ptr [esi+ebx*4],13,10
        lea ebx,[ebx+1]
    .endw
   
    ; dynamisch: array einlesen
    lea esi,pStrDyn
    xor ebx,ebx
    .while ebx < LENGTHOF pStrDyn
        ; string einlesen
        mov pStr,input("string: ")
       
        ; string allozieren
        mov edx,len(pStr)
        inc edx
        mov edi,alloc(edx)
       
        ; string kopieren
        invoke szCopy,pStr,edi

        ; pointer speichern
        mov PCHAR ptr [esi+ebx*4],edi
        lea ebx,[ebx+1]
    .endw
   
    ; ausgabe des dynamischen arrays
    lea esi,pStrDyn
    xor ebx,ebx
    .while ebx < LENGTHOF pStrDyn
        print PCHAR ptr [esi+ebx*4],13,10
        ; gib Speicher frei
        free PCHAR ptr [esi+ebx*4]
        lea ebx,[ebx+1]
    .endw
   
    inkey
    exit
main endp
end main

Die Beschreibung der verwendeten Marcos findest du in \masm32\help\hlhelp.chm.
Wirf auch mal einen Blick in asmintro.chm, masm32.chm, masmlib.chm und opcodes.chm.
GutenAbend
Unregistrierter
Beitrag GutenAbend Unregistrierter 03:42:22 26.12.2011   Titel:              Zitieren
Klasse! Guck ich mir morgen mal an. Wenn ich mir das jetzt noch anschauen würde, würde ich ziemlich viele blöde Fragen stellen :D
nachtfeuer
Mitglied

Benutzerprofil
Anmeldungsdatum: 08.04.2010
Beiträge: 1167
Beitrag nachtfeuer Mitglied 10:18:00 26.12.2011   Titel:              Zitieren
Normalerweise verwendet man einfach die passenden Datentypen, oder man richtet die Daten mit Alignment an passenden Adressen aus, beispielsweise mit align 16.
Oder legt die Strings für + 10h oder so einzeln an, bzw. belegt sie vor.

Mit Befehlen wie z.B.
Assembler Code:
Doppelwort_Stringtangas DD 66 DUP (0)
Assembler Code:
Doppelwort_Stringtangas DD 66 DUP (0)
Assembler Code:
Doppelwort_Stringtangas DD 66 DUP (0)

kann man sich Stringarrays in Doppelwortgröße anlegen. Vorsicht Verwechslungsgefahr: DW meint NICHT Doppelwort.

Dann gibt es noch diverse anderen Assemblerhilfen(direktiven) wie STRUC oder UNION die bei solchen Sachen helfen, oder eben wie masm oben schon beschreibt.

_________________
HhxV9rU5D8o236dZF7bMQ4Dys1_TuUmI4mZM.d2qD15ERi_0dgcHP0UViL3e-4WUi0nXXNwDYqA10sLEgjBVtdhE
tpehI7qHRZESiO_7LhPZFMQWNoiVrJDsEGD26n.H0lV8wOwYAe8UsbUJe5m65NyPaghnSoMzROo2gJ6nTeVSkxLk
a6hvNe11r9U7xddV9mq6NEi_V0C9k4augEKVSW3PV8LgCYum7KaXc9Ijq_ZT7zhspI.=-

Zuletzt bearbeitet von nachtfeuer am 16:43:36 26.12.2011, insgesamt 1-mal bearbeitet
abc.w
Mitglied

Benutzerprofil
Anmeldungsdatum: 25.04.2008
Beiträge: 1364
Beitrag abc.w Mitglied 12:57:11 26.12.2011   Titel:              Zitieren
GutenAbend schrieb:
Sry

Windows 7 x64
masm32
Anfänger :)

Tja, dann versuch erstmal, die Aufgabe in C zu lösen, oder C++, oder wie auch immer in einer Dir vertrauten Programmiersprache.
Dann schreibe ein wenig Testcode, mit dem die Funktion getestet wird, gängige "Use cases", illegale Parameter und was Dir noch so einfällt.
Dann versuche, die Funktion in Assembler zu implementieren und parallel mit dem Testcode zu testen...
Sollte es bereits an der Implementierung in C scheitern - dann gehe und zocke lieber Battle Field oder WoW o.ä.

_________________
E = int * char^2
GutenAbend
Unregistrierter
Beitrag GutenAbend Unregistrierter 16:48:26 26.12.2011   Titel:              Zitieren
@nachtfeuer:
Ja, sowas kam mir auch in etwa in den Sinn. Da ich aber gerade erst mit ASM anfange, wollte ich direkt die "standard" bzw. beste Methode benutzen.

@abc.w:
Wie gesagt, ich suche die beste Methode für ASM.
Der letzte Satz ist übrigens sehr hilfreich :live:

@masm:
Habs mir jetzt mal genauer angeschaut. Das dynamische Array hat mir sehr geholfen

@Alle:
Danke !
abc.w
Mitglied

Benutzerprofil
Anmeldungsdatum: 25.04.2008
Beiträge: 1364
Beitrag abc.w Mitglied 17:26:27 26.12.2011   Titel:              Zitieren
GutenAbend schrieb:
@abc.w:
Wie gesagt, ich suche die beste Methode für ASM.
Der letzte Satz ist übrigens sehr hilfreich :live:

Ich habe Dir die beste Methode gezeigt. Es gibt keine bessere. Zum Schluss hast Du zwei Implementierungen, einmal in einer Hochsprache und einmal in Assembler. Die beiden kannst Du vergleichen - je nach dem, was Du genau vorhast - "Optimize for size" oder "Optimize for speed".
Siehe es auch noch so: Mit dieser Methode sparst Du Zeit und gehst an das Problem objektiv heran und du kannst nachweisen, dass Du etwas verbessert (oder auch verschlechtert) hast.

_________________
E = int * char^2
GutenAbend
Unregistrierter
Beitrag GutenAbend Unregistrierter 18:48:06 26.12.2011   Titel:              Zitieren
@abc.w:
In C++ hab ich das schon einmal gehabt, an sich der gleiche Ansatz wie der von masm. Hab nur gedacht, dass man das in ASM noch etwas "eleganter" lösen könnte...



@masm:
Hab deine Lösung jetzt "übernommen" und modifiziert.
Möchte ich jetzt ungern posten, da der Code einfach durch zahlreiche Experimente ziemlich wild aussieht.
Bin nur etwas von den masm32 Macros abgewichen, dh. ich hab z.B. anstatt "alloc(...)" -> VirtualAlloc bzw HeapAlloc verwendet.
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 ?

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