![\"Hinweise](\"..\/fileadmin\/_temp_\/2014_06\/pic_961_002.png\")
<\/p>\nDie 64-Bit-Version von Access sollten Sie schon deshalb nicht nutzen, weil diese ActiveX-Steuerelemente wie das TreeView-, das ListView- oder das ImageList-Steuerelement nicht unterst\u00fctzt. Aber es gibt noch weitere Gr\u00fcnde: Zum Beispiel k\u00f6nnte es Probleme bei der Verwendung von API-Funktionen geben. Manchmal bleibt einem Entwickler allerdings keine anderen M\u00f6glichkeit, weil etwa am Arbeitsplatz nur die 64-Bit-Version vorliegt oder aber der Kunde mit dieser Version arbeiten muss. Der vorliegende Beitrag liefert Informationen, wie Sie nicht kompatible VBA-Anweisungen f\u00fcr die Zielversion anpassen m\u00fcssen und wie Sie programmieren m\u00fcssen, um die 32-Bit- und die 64-Bit-Version gleicherma\u00dfen zu bedienen. <\/b><\/p>\nUnterschiede zwischen Access 32-Bit und Access 64-Bit<\/h2>\n
Warum entsteht das in der Einleitung beschriebene Dilemma \u00fcberhaupt und was ist mit 32-Bit-Version und 64-Bit-Version \u00fcberhaupt gemeint<\/p>\n
Hierbei beziehen wir uns zun\u00e4chst auf das Betriebssystem. Wenn Sie ein 32-Bit-Betriebssystem nutzen, kann dieses maximal 2 hoch 32 Bytes Arbeitsspeicher adressieren, also ca. 4.096 Megabyte. Bei einem 64-Bit-Betriebssystem kann ein Arbeitsspeicher von 2 hoch 64 Byte adressiert werden – dies wird noch eine Weile ausreichen.<\/p>\n
Wer also mehr als vier Gigabyte Arbeitsspeicher in seinem Rechner verbaut hat und sich wundert, dass davon nur vier angezeigt werden, f\u00e4hrt also vermutlich noch ein 32-Bit-Betriebssystem.<\/p>\n
M\u00f6chten Sie herausfinden, wie viel Arbeitsspeicher Sie nutzen und ob Sie ein 32-Bit- oder ein 64-Bit-Betriebssystem nutzen, k\u00f6nnen Sie dies \u00fcber die Systemsteuerung ermitteln. Unter Windows 7 etwa klicken Sie dazu auf Start|Systemsteuerung <\/b>und dann auf System. Es erscheint der Dialog aus Bild 1, dem Sie die notwendigen Informationen entnehmen k\u00f6nnen. In diesem Fall handelt es sich um ein 64-Bit-System mit acht Gigabyte Arbeitsspeicher.<\/p>\n
<\/p>\n
Bild 1: Hinweise auf Arbeitsspeicher und Betriebssystem in den Systemeinstellungen von Windows<\/span><\/b><\/p>\n Damit kommen wir zum Thema Office und somit auch zu Access. Access 2010 etwa wird standardm\u00e4\u00dfig in der 32-Bit-Variante installiert.<\/p>\n Wer Access 64-Bit w\u00fcnscht, muss dies explizit bei der Installation angeben. Warum das Weil es sehr viele externe Tools und Steuerelemente f\u00fcr Access in der 32-Bit-Version gibt. W\u00fcrden Sie Access in der 64-Bit-Version installieren und versuchen, ein mit der 32-Bit-Version etwa von VB6 entwickeltes Add-In zu starten, f\u00fchrt dies zu einem Fehler.<\/p>\n Das Gleiche gilt, wenn Sie etwa ein 32-Bit-ActiveX-Steuerelement wie das TreeView<\/b>-Steuerelement verwenden m\u00f6chten – mehr dazu weiter unten.<\/p>\n Wenn Sie eine neue Office-Version installieren, k\u00f6nnen Sie diese und anderen Probleme auf einfache Art und Weise umschiffen: Installieren Sie einfach die 32-Bit-Variante. Windows in der 64-Bit-Variante bietet eine Kompatibilit\u00e4tsumgebung namens WOW64<\/b>, mit der Sie 32-Bit-Anwendungen wie in diesem Fall Office und Access ganz normal ausf\u00fchren k\u00f6nnen.<\/p>\n In diesem Fall wird Office nicht in dem daf\u00fcr vorgesehenen Verzeichnis C:Program FilesMicrosoft OfficeOffice15<\/b> installiert, sondern etwa unter C:Program Files (x86)Microsoft OfficeOffice15<\/b>.<\/p>\n Das vermutlich kritisch-ste Problem, das bei der Nutzung von Access in der 64-Bit-Version auftaucht, sind ActiveX-Steuerelemente, die nur in der 32-Bit-Version verf\u00fcgbar sind.<\/p>\n Wir haben testweise eine frische Datenbank unter Access 32-Bit mit einem TreeView-Steuerelement versehen. Wenn Sie diese Datenbank unter Access 64-Bit \u00f6ffnen, l\u00f6st dies zun\u00e4chst die Meldung aus Bild 2 aus.<\/p>\n Bild 2: Der Verweis auf die Datei MSCOMCTL.ocx kann unter Access in der 64-Bit-Version nicht gefunden werden.<\/span><\/b><\/p>\n Wenn Sie diese Meldung ignorieren und dann das Formular mit dem TreeView<\/b>-Steuerelement \u00f6ffnen, erhalten Sie die Meldung aus Bild 3.<\/p>\n Bild 3: Der Container mit dem TreeView-Steuerelement ist leer.<\/span><\/b><\/p>\n Was tun Nun: Es gibt keine 64-Bit-Version dieses Steuerelements, also k\u00f6nnen Sie nur zur 32-Bit-Version von Access wechseln oder eine Alternative f\u00fcr das TreeView<\/b>-Steuerelement suchen.<\/p>\n Wenn Sie eine .mde<\/b>– oder .accde<\/b>-Datei unter Access in der 32-Bit-Version erzeugt haben, k\u00f6nnen Sie diese nur mit der entsprechenden Access-Version \u00f6ffnen. Wenn Sie etwa eine 32-Bit-accde-Datei unter Access in der 64-Bit-Version \u00f6ffnen, erhalten Sie die Fehlermeldung aus Bild 4. In diesem Fall besteht Hoffnung: Wenn Sie Zugriff auf die unkompilierte Version der Datenbankdatei haben, k\u00f6nnen Sie diese unter der 64-Bit-Version von Access kompilieren und die .mde<\/b>\/.accde<\/b>-Datei dann unter Access in der 64-Bit-Version nutzen.<\/p>\n Bild 4: Fehler beim \u00f6ffnen einer .mde- oder .accde-Datei, die mit Access in der 32-Bit-Version erstellt wurde<\/span><\/b><\/p>\n Ein weiteres Problem tritt auf, wenn Sie API-Funktionen, die mit der 32-Bit-Version von Access funktionieren, unter der 64-Bit-Version einsetzen m\u00f6chten. Wir schauen uns dazu die GDI-\/OGL-Bibliothek von Sascha Trowitzsch an, die eine Menge API-Funktionen verwendet, und wollen diese f\u00fcr die 64-Bit-Version lauff\u00e4hig machen.<\/p>\n Wenn Sie das Modul mdlOGL0710 <\/b>unter Access 2013 in der 64-Bit-Version \u00f6ffnen, erhalten Sie einige rot markierte Zeilen wie in Bild 5. Der erste Schritt, um die API-Deklarationen f\u00fcr die 64-Bit-Version nutzbar zu machen, liegt im Hinzuf\u00fcgen eines einfachen Schl\u00fcsselworts, und zwar PtrSafe<\/b>. Dieses Schl\u00fcsselwort f\u00fcgen Sie unmittelbar hinter der Declare<\/b>-Anweisung der API-Funktion ein, sodass etwa die erste in der Abbildung sichtbare Funktion wie in Bild 6 aussieht.<\/p>\n Bild 5: Fehlerhafte API-Deklarationen<\/span><\/b><\/p>\n Bild 6: Hinzuf\u00fcgen des Schl\u00fcsselworts PtrSafe<\/span><\/b><\/p>\n<\/p>\n Auf diese Weise statten Sie nun alle API-Funktionen mit diesem Schl\u00fcsselwort aus. Die Suchen\/Ersetzen-Funktion des VBA-Editors ist dabei eine willkommene Erleichterung: Ersetzen Sie zun\u00e4chst Declare Function <\/b>durch Declare PtrSafe Function <\/b>und dann Declare Sub <\/b>durch Declare PtrSafe Sub<\/b> – klicken Sie dabei jeweils auf Alle ersetzen<\/b> (siehe Bild 7).<\/p>\n <\/p>\n Bild 7: PtrSafe per Suchen\/Ersetzen hinzuf\u00fcgen<\/span><\/b><\/p>\n Sollten sich noch weitere nicht kompatible API-Deklarationen finden, k\u00f6nnen Sie diese durch Bet\u00e4tigen des Men\u00fcbefehls Debuggen|Kompilieren von <\/b>auffinden. Es erscheint dann die Meldung aus Bild 8.<\/p>\n Bild 8: Meldung, wenn beim Debuggen noch inkompatible API-Deklarationen gefunden werden<\/span><\/b><\/p>\n Damit w\u00e4ren schon einmal die Probleme mit der Variablendeklaration behoben.<\/p>\n Nach diesem Problem folgt auch gleich das n\u00e4chste – wenn auch nicht offensichtlich. Dazu bet\u00e4tigen wir nochmals den Debuggen|Kompilieren von <\/b>.<\/p>\n In unserem Beispiel meldet Access nun Fehler beim Kompilieren: Typen unvertr\u00e4glich <\/b>und markiert einen Parameter der API-Funktion GdipCreateBitmapFromFile<\/b> (siehe Bild 9). Hier wird offensichtlich eine Funktion namens StrPtr <\/b>verwendet, um der Funktion die Adresse der Variablen sFileName <\/b>zu \u00fcbermitteln.<\/p>\n Bild 9: Datentyp-Fehler<\/span><\/b><\/p>\n Was geht hier schief Schauen wir uns die Funktion StrPtr <\/b>an, indem wir das Kontextmen\u00fc zu diesem Befehl \u00f6ffnen und den Eintrag Definition <\/b>ausw\u00e4hlen. Dies f\u00fchrt zun\u00e4chst zur Fehlermeldung aus Bild 10.<\/p>\n Bild 10: Problem beim Anzeigen der Funktion StrPtr<\/span><\/b><\/p>\n Das ist aber kein Problem: Wir aktivieren im Objektkatalog mit einem Klick auf den Eintrag Verborgene Eintr\u00e4ge anzeigen <\/b>des Kontextmen\u00fcs die Anzeige der verborgenen Elemente.<\/p>\n Anschlie\u00dfend versuchen wir erneut, die Definition der Funktion StrPtr<\/b> im Objektkatalog anzuzeigen. Diesmal gelingt es, wie Bild 11 zeigt. Hier erfahren wir dann, dass StrPtr <\/b>einen Wert des Datentyps LongPtr <\/b>zur\u00fcckliefert. Damit schauen wir uns nun die Definition der API-Funktion an:<\/p>\n Bild 11: Anzeigen der Funktion StrPtr im Objektkatalog<\/span><\/b><\/p>\n Hier sehen wir nun, dass der erste Parameter nicht mit dem Datentyp LongPtr<\/b>, sondern mit dem Datentyp Long <\/b>definiert ist. Schauen wir uns den gleichen Code auf einem Rechner mit Office in der 32-Bit-Version an, so f\u00fchrt das Kompilieren dieser Definition der API-Funktion nicht zu einem Fehler – der LongPtr<\/b>-Wert kann also wohl problemlos f\u00fcr den Long<\/b>-Parameter angegeben werden.<\/p>\n Aber worum handelt es sich bei diesem LongPtr<\/b>-Datentyp eigentlich Er wurde mit VBA 7 eingef\u00fchrt und nimmt wie der Long<\/b>-Datentyp Ganzzahlen auf.<\/p>\n Der Datentyp Long <\/b>unterst\u00fctzt einen Wertebereich von -2.147.483.648 bis 2.147.483.647. Welchen Wertebereich der Datentyp LongPtr <\/b>unterst\u00fctzt, h\u00e4ngt von der Office-Version ab:<\/p>\n Sprich: Bei Verwendung der 32-Bit-Version verwenden Long <\/b>und LongPtr <\/b>den gleichen Wertebereich. Deshalb gibt es auch in der 32-Bit-Version keinen Fehler, wenn Sie einer Long<\/b>-Variablen einen Wert zuweisen, der durch die Funktion StrPtr <\/b>ermittelt wurde.<\/p>\n In der 64-Bit-Version liegt dieser Fehler jedoch vor, weshalb wir schlicht und einfach den Datentyp der Parameter in den betreffenden API-Funktionen von Long <\/b>in LongPtr <\/b>\u00e4ndern. Da dieser Datentyp auch unter VBA 7 in der 32-Bit-Version unterst\u00fctzt wird, erhalten wir die volle Kompatibilit\u00e4t – vorausgesetzt, VBA 7 wird verwendet.<\/p>\n Damit gehen wir nun weiter und schauen, wo es noch Probleme gibt. Diese halten sich im Rahmen: Sie m\u00fcssen im Beispielmodul lediglich noch hier und da den Datentyp Long <\/b>durch LongPtr<\/b> ersetzen, und zwar in API-Funktionen als auch in Type-Elementen.<\/p>\n Wenn Sie eine Anwendung also durch Ersetzen des Datentyps Long <\/b>durch LongPtr <\/b>64-Bit-f\u00e4hig gemacht haben, k\u00f6nnen Sie diese unter Windows 7 (nat\u00fcrlich in der 64-Bit-Variante) unter Office in der 32-Bit- und in der 64-Bit-Version nutzen.<\/p>\n Was nun noch fehlt, ist die Pr\u00fcfung der Abw\u00e4rtskompatibilit\u00e4t. Wie sieht es aus, wenn wir den Code unter einer Office-Version nutzen wollen, die noch VBA 6 nutzt – was ja nicht 64-Bit-f\u00e4hig ist Dies pr\u00fcfen wir, indem wir den betroffenen Code auf einem Rechner mit dem entsprechenden Office-Paket kompilieren und ausf\u00fchren. Hier tritt dann gleich der Fehler aus Bild 12 auf – VBA erkennt den Befehl PtrSafe <\/b>nicht.<\/p>\n Bild 12: Fehler beim Kompilieren unter Access 2003<\/span><\/b><\/p>\n Kein Wunder, denn wir verwenden ja hier auch die Version 6.0 von VBA (s. Bild 13).<\/p>\n Bild 13: Ermittlung der VBA-Version<\/span><\/b><\/p>\n Was also k\u00f6nnen wir tun, damit der f\u00fcr die 64-Bit-Version von Access angepasste Code nun auch f\u00fcr \u00e4ltere Versionen von VBA kompatibel ist Dazu nutzen wir eine von zwei neuen Kompilierungskonstanten. Dabei handelt es sich um Konstanten, die f\u00fcr die bedingte Kompilierung genutzt werden – eine M\u00f6glichkeit, Codezeilen nur dann zu kompilieren, wenn eine bestimmte Bedingung eintritt.<\/p>\n Ein einfaches Beispiel sieht wie folgt aus – hier wird schlicht in Abh\u00e4ngigkeit der Kompilierungskonstante VBA7 ein entsprechender Ausdruck im Direktfenster ausgegeben:<\/p>\n Diese Kompilierungskonstante funktioniert nur in Anweisungen der bedingten Kompilierung, also mit #If…Then<\/b>, #If…Then…Else<\/b>, #Else <\/b>und #End If<\/b>.<\/p>\n Die #If…Then<\/b>-Bedingung pr\u00fcft den Wert der Kompilierkonstanten VBA7 <\/b>und f\u00fchrt dann entweder den #If<\/b>– oder den #Else<\/b>-Teil der Bedingung aus.<\/p>\n In unserem Fall f\u00fcgen wir dem If<\/b>-Teil der Bedingung beispielsweise die API-Deklaration mit dem PtrSafe<\/b>-Schl\u00fcsselwort hinzu, dem Else<\/b>-Teil die gleiche API-Deklaration ohne das PtrSafe<\/b>-Schl\u00fcsselwort (s. Listing 1).<\/p>\n Listing 1: Verschiedene Deklarationen per bedingter Kompilierung<\/span><\/b><\/p>\n Auf die gleiche Art und Weise fassen wir die kompletten API-Deklarationen einmal in den If<\/b>– und einmal in den Then<\/b>-Teil ein, das Gleiche gilt f\u00fcr die \u00fcbrigen unter VBA 6.0 nicht kompilierbaren Anweisungen, die Sie nachfolgend durch wiederholtes Kompilieren aufdecken.<\/p>\n Bei den API-Deklarationen m\u00fcssen Sie bei der VBA 6.0-Variante nat\u00fcrlich auch noch die LongPtr<\/b>-Parameter in Long<\/b>-Parameter zur\u00fcckverwandeln.<\/p>\n Die Beispieldatenbank VBA64.mdb<\/b> enth\u00e4lt nun Code, der sowohl unter VBA 6.0 als auch unter VBA 7.0 in der 32-Bit- und der 64-Bit-Version funktioniert.<\/p>\n Es gibt noch weitere m\u00f6gliche Unterschiede zwischen der 32-Bit- und der 64-Bit-Version von VBA. W\u00e4hrend die bisher in diesem Beitrag vorgestellten \u00e4nderungen, die zur Sicherstellung der Kompilierbarkeit unter der 64-Bit-Version n\u00f6tig waren, zur 32-Bit-Version abw\u00e4rtskompatibel sind, gibt es auch noch solche, die unter der 32-Bit-Version nicht kompilierbar sind.<\/p>\n Allerdings halten sich diese \u00e4nderungen in Grenzen: Nach unseren Erkenntnissen handelt es sich allein um den Datentyp LongLong<\/b>.<\/p>\n Dessen Wertebereich sollte eigentlich von -9.223.372.036.854.775.808 <\/b>bis 9.223.372.036.854.775.807<\/b> reichen – also von -263 bis 263-1.<\/p>\n F\u00fcr den bei der Erstellung der Beispiele zu diesem Beitrag verwendeten Rechner haben wir mit folgender Prozedur experimentell aber andere Werte ermittelt:<\/p>\n Das Ergebnis im Direktfenster sieht dann so aus:<\/p>\n Mit einigen Tausendertrennzeichen f\u00fcr die bessere Lesbarkeit ergibt dies einen Wertebereich von -9.223.372.036.854.775.808<\/b> bis 9.223.372.036.854.774.784<\/b>.<\/p>\n Ob die aktuelle Office-Version nun im 32-Bit- oder im 64-Bit-Betrieb l\u00e4uft, ermitteln Sie mit der Win64<\/b>-Kompilierkon-stanten. Hier ein kleines Beispiel:<\/p>\n Nun k\u00f6nnen Sie aber keine Variablen deklarieren, die den Typ LongLong <\/b>verwenden und auch dessen Wertebereich aussch\u00f6pfen und diese dann auch f\u00fcr Office in der 32-Bit-Variante zug\u00e4nglich machen. Dies wird allerdings auch etwa von API-Funktionen ber\u00fccksichtigt – wie etwa von der fiktiven Funktion MyMathFunction<\/b>. Diese deklarieren Sie f\u00fcr gr\u00f6\u00dftm\u00f6gliche Kompatibilit\u00e4t einfach wie in Listing 2.<\/p>\n Listing 2: Deklaration einer API-Funktion f\u00fcr 64-Bit- und 32-Bit-VBA<\/span><\/b><\/p>\n Links:<\/b><\/p>\n TreeView 64bit ist da – Anwendungen umr\u00fcsten<\/a><\/p>\n GUIDs per VBA erstellen (64-bit-kompatibel)<\/a><\/p>\n Zwischenablage per VBA, 64-Bit-Version<\/a><\/p>\n<\/p>\n Enthaltene Beispieldateien:<\/p>\n VBA64.mdb<\/p>\n Download<\/a><\/p>\n TreeView 64bit ist da – Anwendungen umrüsten<\/a><\/p>\nOffice mit 32-Bit und 64-Bit<\/b><\/h2>\n
Einfache L\u00f6sung<\/b><\/h2>\n
Probleme mit ActiveX-Steuerelementen<\/b><\/h2>\n
![\"Der](\"..\/fileadmin\/_temp_\/2014_06\/pic_961_010.png\")
<\/p>\n![\"Der](\"..\/fileadmin\/_temp_\/2014_06\/pic_961_011.png\")
<\/p>\nProbleme mit mde\/accde unter Access 64-Bit<\/b><\/h2>\n
![\"Fehler](\"..\/fileadmin\/_temp_\/2014_06\/pic_961_003.png\")
<\/p>\nProbleme mit API-Deklarationen<\/b><\/h2>\n
![\"Fehlerhafte](\"..\/fileadmin\/_temp_\/2014_06\/pic_961_015.png\")
<\/p>\n![\"Hinzuf\u00fcgen](\"..\/fileadmin\/_temp_\/2014_06\/pic_961_016.png\")
<\/p>\n![\"PtrSafe](\"..\/fileadmin\/_temp_\/2014_06\/pic_961_017.png\")
<\/p>\n![\"Meldung,](\"..\/fileadmin\/_temp_\/2014_06\/pic_961_018.png\")
<\/p>\nProbleme mit Variablentypen<\/b><\/h2>\n
![\"Datentyp-Fehler\"](\"..\/fileadmin\/_temp_\/2014_06\/pic_961_019.png\")
<\/p>\n![\"Problem](\"..\/fileadmin\/_temp_\/2014_06\/pic_961_020.png\")
<\/p>\n![\"Anzeigen](\"..\/fileadmin\/_temp_\/2014_06\/pic_961_021.png\")
<\/p>\nPrivate <\/span>Declare PtrSafe Function GdipCreateBitmapFromFile_O Lib \"ogl\" Alias \"GdipCreateBitmapFromFile\" _\n (ByVal FileName As Long<\/span>, bitmap As Long<\/span>) As Long<\/span><\/pre>\nDer LongPrt-Datentyp f\u00fcr Access 64-bit<\/h2>\n
\n
Kompatibilit\u00e4t mit \u00e4lteren VBA-Versionen<\/b><\/h2>\n
![\"Fehler](\"..\/fileadmin\/_temp_\/2014_06\/pic_961_022.png\")
<\/p>\n![\"Ermittlung](\"..\/fileadmin\/_temp_\/2014_06\/pic_961_023.png\")
<\/p>\nKompatibilit\u00e4t per Kompilierungskonstante<\/b><\/h2>\n
Public Sub <\/span>TestVBA7()\n #If vba7 Then\n Debug.Print<\/span> \"VBA7 wird genutzt.\"\n #Else\n Debug.Print<\/span> _\n \"VBA7 wird nicht genutzt.\"\n #End If\nEnd Sub<\/span><\/pre>\n#If vba7 Then\nPrivate <\/span>Declare PtrSafe Function OleCreatePictureIndirect Lib \"oleaut32.dll\" _\n (lpPictDesc As <\/span>PICTDESC, riid As <\/span>GUID, _\n ByVal fPictureOwnsHandle As Long<\/span>, IPic As Object<\/span>) As Long<\/span>\n#Else\nPrivate <\/span>Declare Function OleCreatePictureIndirect Lib \"oleaut32.dll\" _\n (lpPictDesc As <\/span>PICTDESC, riid As <\/span>GUID, _\n ByVal fPictureOwnsHandle As Long<\/span>, IPic As Object<\/span>) As Long<\/span>\n#End If<\/pre>\nUnterschiede zwischen 32-Bit und 64-Bit<\/b><\/h2>\n
Public Sub <\/span>TestLongLong()\n Dim <\/span>lnglng As Long<\/span>Long\n lnglng = Eval(\"-2^63-1024\")\n Debug.Print<\/span> \"LongLong minimal: \" _\n & lnglng\n lnglng = Eval(\"2^63-513\")\n Debug.Print<\/span> \"LongLong maximal: \" _\n & lnglng\nEnd Sub<\/span><\/pre>\nLongLong minimal: -9223372036854775808\nLongLong maximal: 9223372036854774784<\/pre>\n
Public Sub <\/span>Test64-Bit()\n #If Win64 Then\n Debug.Print<\/span> \"Win64\"\n #Else\n Debug.Print<\/span> \"Anderes\"\n #End If\nEnd Sub<\/span><\/pre>\n#If Win64 Then\n Declare PtrSafe Function MyMathFunc Lib \"user32\" (ByVal N As Long<\/span>Long) As Long<\/span>Long\n#Else\n Declare PtrSafe Function MyMathFunc Lib \"user32\" (ByVal N As Long<\/span>) As Long<\/span>\n#End If<\/pre>\nhttp:\/\/msdn.microsoft.com\/de-de\/library\/office\/ee691831(v=office.14).aspx\nhttp:\/\/windows.microsoft.com\/de-de\/windows\/32-bit-and-64-bit-windows#1TC=windows-7\nhttp:\/\/www.hardwareschotte.de\/magazin\/32-bit-vs-64-bit-wo-ist-der-unterschied-a41592<\/pre>\n
Weitere interessante Artikel zu diesem Thema<\/h2>\n
Downloads zu diesem Beitrag<\/h2>\n
Weitere interessante Artikel zu diesem Thema<\/h2>\n