Matrix in einer Binärdatei auslesen?

KN4CK3R

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

sieht auch seltsam aus

SeppJ

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?

Nathan

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 |!
std::ios::binary||std::ios::out sollte 1 ergeben und nicht std::ios::binary|std::ios::out

KN4CK3R

genau, das meinte ich. ~~sollte doch eigentlich auch eine Warnung erzeugen weil es doch bool erzeugt oder nicht?~~

SeppJ

Nathan schrieb:

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.

Irgendwie bin ich echt zu dumm dafür.. Ich bekomme jetzt zwar was ausgegeben, aber nur die Adressen

#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;
}

SeppJ

Hier mal eine flotte Korrektur deines Codes:

#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';
          }
      }   
  }
}

KN4CK3R

Machs doch so, wie du sie auch befüllst mit zwei Schleifen?
Außerdem hast du immernoch den Fehler mit den Flags bei open(...) drin.

Dankeschön Leute, jetzt funktioniert es. Ich habe den Code von SeppJ benutzt und es klappt einwandfrei.

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.

SeppJ

Benutzer123 schrieb:

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.

SeppJ schrieb:

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.