Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (WinAPI, Konsole) » binäres öffnen

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 <
000
07.10.2007, 18:31 Uhr
~5000 Watt
Gast


Hallo,

ich hab noch nicht sehr lange mit C++ zu tun und wollte einfach mal Fragen, was das binäre öffnen von Dateien macht. Greife ich dann die Einsen und Nullen zu oder kann ich einfach nur die Steuerzeichen lesen?

Wenn das Zweite zutrifft, wäre es nett, wenn ihr mir sagen würdet, wie ich die Einsen und Nullen lesen kann, oder muss ich dann erst umrechnen?

Ich weis, dass diese Frage noobig ist, aber ich bin ja auch noch ein Noob.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
08.10.2007, 08:05 Uhr
RedEagle



Lesen:

C++:
FILE *fp;
fp = fopen(".\\file.bin", "rb"); //r für read, b für binary
if(fp == NULL) return 1;

char var;
var = fgetc(fp);

fclose(fp);



Zum thema 1/0:
Es gibt mehrere Möglichkeiten, 2 Zustände zu speichern.
bsp.: man will 8 Zustände speichern, bzw in diesem Fall lesen

1. Pro Zustand 1 Byte
Man braucht dann nur die Bytes einlesen (s.o.). Optimal währe es, wenn man sie ASCII-Codiert (also '1' und '0'), Es können aber auch 0x01 oder 0x00 sein.

2. Alles in einem Byte
Man liest das Byte ein (s.o.) und muss sich die einzelnen Bits raussuchen.

bsp.:

C++:
void bits(char c, bool *ba)
{
short maske = 0x0001;
for(short i=0; i<8; i++)
{
  ba[i] = c&maske;
  maske <<= 1;
}
}

Aufruf:

C++:
bool zustande[8];
bits(var, zustande);

--
MFG RedEagle
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
08.10.2007, 09:58 Uhr
~5000 Watt
Gast


Danke für die schnelle Antwort, hab aber gleich ne Frage zu deinem Code:

Du machst ne Funktion, die nichts zurückgibt und ein Zeichen und einen Zeiger auf ein nen bool nimmt, stimmt das?

jetzt legst du ne Variable an, die "maske" heißt und und mit 0x0001 initialisiert wird. Jezt liest du in einer Schleife einzeln die 8 Bits von c ein und legst sie dort in ba ab, wo die Maske eine 1 hat. Und jetzt wird die gesamte Maske eine Pos nach links geshiftet.

Wie muss ich jetzt das 0x0001 interprätieren?
Hat die Maske jetzt nicht den Wert 1?
Kann man die Maske also nicht auch mit "1" initialisieren?
Und was macht das "x"?
Und warum legst du in der Maske nicht 8 Bits ab?
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
08.10.2007, 10:20 Uhr
RedEagle



0x0001 ist die hexadezimale Schreibweise für 1.
Das 0x vor der Zahl sagt nur, dass es sich um eine Hexadezimalzahl handelt.
Ich habe die 1 als Hexadezimalzahl genommen, weil ich mit dieser Variable binäroperationen durchführe. (also nur aus optischen Gründen)
...und die drei führenden Nullen vor der 1, damit deutlich wird, dass alle Bits, außer dem 1. =0 sind. (auch eine rein optischer Maßnahme)

C++:
short maske = 1;

hätte gereicht

---

mal angeneommen, c hat den Wert 18, und maske 1
18 dezimal ist 00010010 binär (bzw 10010)
1 dezimal ist 00000001 binär (bzw 1)

1. Schleifendurchlauf:
ba[0] = 00010010 & 00000001
=> ba[0] = 0 weil 0&1=0
maske <<= 1 verschiebt alle bits in maske um 1 nach links
=> maske = 00000010 (oder 2)

2. Schleifendurchlauf:
ba[1] = 00010010 & 00000010
=> ba[1] = 1 weil 1&1=1
maske <<= 1 verschiebt alle bits in maske um 1 nach links
=> maske = 00000100 (oder 4)

---

Zu der Funktion:
ich übergebe der Funktion die Adresse eines bool-arrays.
Innerhalb der Funktion schreibe ich werte in den Adressierten Speicher; Somit sind die werte auch dort vorhanden, wo die Funktion aufgerufen wurde, und ich die adresse übergeben habe.
bsp.:

C++:
void fnc(int *arg)
{
arg[0] = 1;
arg[1] = 2;
return;
}

int main()
{
int x[2];
fnc(x);
if(x[0] == 1 && x[1] == 2) printf("Hallo Welt");
return 0;
}

--
MFG RedEagle

Dieser Post wurde am 08.10.2007 um 10:27 Uhr von RedEagle editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
004
08.10.2007, 10:39 Uhr
~5000 Watt
Gast


Kann man das auch so machen?


C++:
void bits(char c, bool *ba)
{
for(int i = 8; i >= 0; i--)
   {
     ba[i] = c % 2;

     c /= 2;
   }
}



Also ich teile c immer durch 2 und notiere mir dann immer den Rest.
Muss bloß immer von hinten anfangen.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
005
08.10.2007, 10:46 Uhr
~5000 Watt
Gast


Und wie lese ich einem ifstream binär?


C++:
ifstream myfile(ios:: ...);



Also was kommt an die Stelle mir den "..."?
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
006
08.10.2007, 10:48 Uhr
RedEagle



Ja, aber ein array mit 8 elementen geht von 7 bis 0
int i=7;

zu den ifstreams:
www.cplusplus.com/reference/iostream/ifstream/open.html
also als flag beim öffnen noch binary anhängen

einlesen:

C++:
char var;
var = myfile.get();


--
MFG RedEagle

Dieser Post wurde am 08.10.2007 um 10:51 Uhr von RedEagle editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
007
08.10.2007, 11:00 Uhr
~5000 Watt
Gast


Also, wenn ich NICHT binär öffne, öffne ich die Datei als Text und kann nur druckbare Zeichen einlesen.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
008
08.10.2007, 18:12 Uhr
0xdeadbeef
Gott
(Operator)


Ich würd dafür wohl direkt den vector<bool> benutzen, etwa in der Art:

C++:
#include <algorithm>
#include <fstream>
#include <iostream>
#include <iterator>
#include <limits>
#include <string>
#include <vector>

class char_append {
public:
  char_append(std::vector<bool> &vec) : vec_(vec) { }

  void operator()(char c) {
    static std::size_t const cbits
      = std::numeric_limits<unsigned char>::digits;

    vec_.resize(vec_.size() + cbits);

    for(std::size_t i = 0; i < cbits; ++i) {
      vec_[vec_.size() - i - 1] = c >> i & 1; // gsb
    }
  }

private:
  std::vector<bool> &vec_;
};

int main() {
  std::ifstream in("foo.txt", std::ios::binary);
  std::vector<bool> vec;

  std::for_each(std::istreambuf_iterator<char>(in.rdbuf()),
                std::istreambuf_iterator<char>(),
                char_append(vec));

  std::copy(vec.begin(), vec.end(), std::ostream_iterator<bool>(std::cout, ""));
  std::cout << std::endl;
}


...allerdings frage ich mich ein bisschen, wofür du die Bitabfolge eigentlich brauchst - zumal die so oder so bezüglich der Stellung des kleinsten bzw. größten Bits nicht eindeutig ist. In aller Regel macht es mehr Sinn, mit Bytes zu arbeiten, und die, falls nötig, später auseinanderzupfriemeln.
--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 <     [ C / C++ (WinAPI, Konsole) ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: