Zunächst habe ich mir eine Matrix deklariert und sie mit Werten belegt :

const int ZEILEN = 10, SPALTEN = 8;
	double matrix[ZEILEN][SPALTEN];
	for (int i=0; i<ZEILEN; ++i) {
		for (int j=0; j<SPALTEN; ++j) {
			matrix[i][j] = 10;
		}
	}

Schließlich habe ich diese Matrix binär in eine Textdatei (unformatiert) geschrieben :

ziel.write(reinterpret_cast<const char*>(matrix), sizeof(matrix));

Ich frage mich, wie ich diese Matrix (bzw. die Werte der Matrix) wieder auslesen kann. Es wäre wirklich toll wenn mir jemand dazu mal eine kleine Erklärung geben könnte, weil ich das Prinzip der Binären Ein/-Ausgabe noch nicht so ganz verstanden habe.

while (quelle.read(reinterpret_cast<char*>(matrix1), sizeof(matrix1)))

Scheinbar überspringt er die Schleife direkt, da er nichts auslesen kann. Das "write" hat aber funktioniert, da alle Dateien einen Inhalt haben.

const int ZEILEN = 10, SPALTEN = 8;
	double matrix[ZEILEN][SPALTEN];
	for (int i=0; i<ZEILEN; ++i) {
		for (int j=0; j<SPALTEN; ++j) {
			matrix[i][j] = 10;
		}
	}
	// Abfrage der Daten
	std::string a;
	std::cout << "Geben Sie den gewuenschten Dateinamen ein: ";
	std::cin >> a;
	std::ofstream(a.c_str());

	// binär
	std::ofstream ziel;
	ziel.open(a.c_str(), std::ios::binary||std::ios::out);
	if (!ziel) {
		std::cerr << "Die Datei " 
			<< a.c_str() << " konnte nicht geoeffnet werden!";
		std::exit(-1);
	}
	ziel.write(reinterpret_cast<const char*>(matrix), sizeof(matrix));

	std::ifstream quelle;
	int i = {0};
	double matrix1[ZEILEN][SPALTEN];
	quelle.open(a.c_str(), std::ios::binary||std::ios::in);
	while (quelle.read(reinterpret_cast<char*>(matrix1), sizeof(matrix1)))
		std::cout << matrix1[i] << std::endl;

Ungestestet:

{
    // binär
    std::ofstream ziel;
    ziel.open(a.c_str(), std::ios::binary||std::ios::out);
    if (!ziel) {
        std::cerr << "Die Datei "
            << a.c_str() << " konnte nicht geoeffnet werden!";
        std::exit(-1);
    }
    ziel.write(reinterpret_cast<const char*>(matrix), sizeof(matrix));
  }

  {
    std::ifstream quelle;
    int i = {0};
    double matrix1[ZEILEN][SPALTEN];
    quelle.open(a.c_str(), std::ios::binary||std::ios::in);
    while (quelle.read(reinterpret_cast<char*>(matrix1), sizeof(matrix1)))
        std::cout << matrix1[i] << std::endl; 
  }

P.S.: Außerdem ist deine Ausgabe am Ende komisch. Du gibst ja nur das (0,0)er Element aus. Du willst wohl eher:

while(leseaktion)
{
  schleifen über alle elemente
  {
     ausgabe;
  }
}

Solch eine Ausgabe ist auch immer etwas, das man schön in eine eigene Funktion packen kann. Wenn die erst einmal richtig gemacht ist, dann passieren solche Fehler bei der Ausgabe gar nicht mehr, wenn man immer diese Funktion benutzt.

sieht auch seltsam aus

std::ios::binary||std::ios::out

sieht auch seltsam aus

Das mit dem ||std::ios::out koennte man sich sparen, aber es ist an sich nicht falsch. Oder was meinst du genau?

KN4CK3R schrieb:

std::ios::binary||std::ios::out

sieht auch seltsam aus

Das mit dem ||std::ios::out koennte man sich sparen, aber es ist an sich nicht falsch. Oder was meinst du genau?

Das ist || nicht |!
std::ios::binary||std::ios::out sollte 1 ergeben und nicht std::ios::binary|std::ios::out

SeppJ schrieb:

KN4CK3R schrieb:

std::ios::binary||std::ios::out

sieht auch seltsam aus

Das mit dem ||std::ios::out koennte man sich sparen, aber es ist an sich nicht falsch. Oder was meinst du genau?

Das ist || nicht |!

Ups, irgendwie bin ich blind heute.

#include <iostream>
#include <fstream>
#include <string>
#include <cstdlib>

int main (void) {
	const int ZEILEN = 10, SPALTEN = 8;
	double matrix[ZEILEN][SPALTEN];
	for (int i=0; i<ZEILEN; ++i) {
		for (int j=0; j<SPALTEN; ++j) {
			matrix[i][j] = 10;
		}
	}
	// Abfrage der Daten
	std::string a;
	std::cout << "Geben Sie den gewuenschten Dateinamen ein: ";
	std::cin >> a;
	std::ofstream(a.c_str());

	{ 
    // binär 
    std::ofstream ziel; 
    ziel.open(a.c_str(), std::ios::binary||std::ios::out); 
		if (!ziel) { 
			std::cerr << "Die Datei " 
				<< a.c_str() << " konnte nicht geoeffnet werden!"; 
			std::exit(-1); 
		} 
		ziel.write(reinterpret_cast<const char*>(*matrix), sizeof(matrix)); 
   } 

  { 
    std::ifstream quelle; 
    int i = {0}; 
    double matrix1[ZEILEN][SPALTEN]; 
    quelle.open(a.c_str(), std::ios::binary||std::ios::in); 
    while (quelle.read(reinterpret_cast<char*>(matrix1), sizeof(matrix1))) {
		int anz = ZEILEN * SPALTEN;
		for (size_t i=0; i<anz; ++i) {
			std::cout << *(matrix+i) << std::endl;
		}
	}

  }

	std::system("PAUSE");
	return 0;
}

#include <iostream>
#include <fstream>
#include <string>
#include <cstdlib>

int main ()
{
  const int ZEILEN = 10, SPALTEN = 8;
  double matrix[ZEILEN][SPALTEN];
  for (int i=0; i<ZEILEN; ++i) 
    {
      for (int j=0; j<SPALTEN; ++j) 
        {
          matrix[i][j] = 10;
        }
    }
  // Abfrage der Daten
  std::string a;
  std::cout << "Geben Sie den gewuenschten Dateinamen ein: ";
  std::cin >> a;
  std::ofstream(a.c_str());

  {
    // binär
    std::ofstream ziel(a.c_str(), std::ios::binary);
    if (!ziel) {
      std::cerr << "Die Datei "
                << a.c_str() << " konnte nicht geoeffnet werden!";
      std::exit(-1);
    }
    ziel.write(reinterpret_cast<const char*>(*matrix), sizeof(matrix));
  }

  {
    std::ifstream quelle(a.c_str(), std::ios::binary);
    double matrix1[ZEILEN][SPALTEN];
    while (quelle.read(reinterpret_cast<char*>(matrix1), sizeof(matrix1))) 
      {
        for (size_t x = 0; x < ZEILEN; ++x) 
          {
            for (size_t y = 0; y < SPALTEN; ++y)
              std::cout << matrix1[x][y] << '\t';
            std::cout << '\n';
          }
      }   
  }
}

PS: Auch danke für den Tipp bezüglich der Variablen, die ich lokal halten soll, das bringt echt mehr Struktur und sorgt für weniger Fehler.

PS: Auch danke für den Tipp bezüglich der Variablen, die ich lokal halten soll, das bringt echt mehr Struktur und sorgt für weniger Fehler.

Ist dir denn klar, was (ausser dem "||" statt "|") falsch war? Du hattest einen ofstream, der die Datei geoeffnet hatte. Dann hast du einen ifstream genommen, der die gleiche Datei aufgemacht hat. Der ofstream hatte die Datei aber noch zum Schreiben offen. Die meisten Systeme erlauben so etwas nicht und daher schlug das Oeffnen fehl. Dadurch, dass die beiden Streams lokaler gemacht wurden, wurde die Datei vom ofstream automatisch geschlossen, als dieser seinen Gueltigkeitsbereich verliess und daher funktionierte dann das Oeffnen mit dem ifstream.
Theoretisch haette man auch ein close() auf dem ofstream machen koennen, aber mit den Gueltigkeitsbereichen ist es, wie du selber bemerkt hast, sauberer und weniger fehleranfaellig.

Dann hast du einen ifstream genommen, der die gleiche Datei aufgemacht hat. Der ofstream hatte die Datei aber noch zum Schreiben offen. Die meisten Systeme erlauben so etwas nicht und daher schlug das Oeffnen fehl.

Die meisten? Fällt dir außer Windows noch eins ein? Keine Klugscheißerei, ehrliche Frage.