So sieht die Header-Datei aus (headers/header.h):

#ifndef LEARN_HEADER
#define LEARN_HEADER

#include <iostream>
#include <string>
#include <fstream>
#include <vector>

using std::string;
using std::vector;
using std::cout;
using std::cin;
using std::ifstream;
using std::ios;

char readfile()
{
	int length;
	char * buffer;

	//define handler and open file
	ifstream is;
	is.open("/Users/lumio/Developer/learning/learn/tmp.txt", ios::binary);

	//get length of file
	is.seekg(0, ios::end);
	length = is.tellg();
	is.seekg(0, ios::beg);

	buffer = new char[length];

	//read file
	is.read(buffer, length);
	is.close();

	cout.write(buffer, length);
	delete[] buffer;
	return 'a';
}

#endif

Die main.cpp sieht so aus:

#include "headers.h"

vector<string> array;

int main (int argc, char * const argv[]) {
	readfile();
	return 0;
}

Als ausgabe kommt dann folgendes:

Loading program into debugger…
GNU gdb 6.3.50-20050815 (Apple version gdb-962) (Sat Jul 26 08:14:40 UTC 2008)
Copyright 2004 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB. Type "show warranty" for details.
This GDB was configured as "i386-apple-darwin".Program loaded.
sharedlibrary apply-load-rules all
Attaching to program: `/Users/lumio/Developer/learning/learn/build/Debug/learn', process 708.

Sorry für den langen Post

1. using in Header-Dateien

2. massenhaftes inkludieren von Header-Dateien (inkludiere Header-Dateien dort, wo sie gebraucht werden)

Grüße... Heiko

Warum soll ich using nicht in header-Dateien verwenden?
Warum soll ich keine Massen-includes in header-Dateien machen bzw nur da wo ich sie brauche?

Und wie soll ich die Datei einlesen?
Ich wollte nach diesem Beispiel hier gehen:
http://www.cplusplus.com/reference/iostream/istream/read/

Danke

Ganze Zeilen einlesen, solange Dateiende nicht erreicht:

#include<iostream>
#include<fstream>
#include<vector>
#include<string>

int main()
{
   std::string temp;
   std::vector<std::string> dateiinhalt;
   std::ifstream input("deinedatei.txt");//ifstream ist zum lesen da

   while(getline(input,temp))
   {
       dateiinhalt.push_back(temp);
   }
}

Wortweises einlesen einer Datei:

#include<iostream>
#include<fstream>
#include<vector>
#include<string>

int main()
{
   std::string temp;
   std::vector<std::string> dateiinhalt;
   std::ifstream input("deinedatei.txt");//ifstream ist zum lesen da

   while(input>>temp)
   {
       dateiinhalt.push_back(temp);
   }
}

Man beachte die whiles, diese unterscheiden sich pro Version.

//edit: bzw. warum ist es nicht gut, die Datei binary zu lesen?

Warum soll ich using nicht in header-Dateien verwenden?

Weil du damit den Namespace aushebelst. Sobald du irgendwo das Headerfile inkludierst, ist auch dort die using-Anweisung drin. Dadurch läufst du Gefahr, irgendwann einen Namenskonflikt zu haben. Die using Anweisung kann man nicht wieder zurücksetzen.
Auch wirst du dich entsprechend ärgern, wenn das Headerfile zu einer Bibliothek gehört, welche du benutzt. Denn dann hast du überhaupt keine Möglichkeit, dies zu verändern. Du wirst nur die Bibliothek und den Programmierer verfluchen können

Also die using-Anweisungen entweder in einen Scope rein, denn die Dinger sind auch Scope abhängig und nur in den globalen Scope, wenn du dich in einem Implementationfile befindest. Aber auch dort, würde ich aufpassen mit dem Zumüllen vom globalen Scope. Namespaces haben schliesslich ihre Berechtigung

Lumio schrieb:

Warum soll ich keine Massen-includes in header-Dateien machen bzw nur da wo ich sie brauche?

Weil du damit unnötige Abhängigkeiten machst. Gerade in IDEs gibt es die Möglichkeit, dass man nur die veränderten Sachen neu kompilieren muss. Wenn du nun ein Projekt hast, welches für einen kompletten Build 30 Minuten braucht (was nicht abnormal ist!), dann bist du froh, wenn du etwas in einem Header veränderst und nur der veränderte Teil neu kompiliert werden muss. Wenn du unnötige Abhängigkeiten geschaffen hast, dann muss alles neu kompiliert werden, jedesmal

Zudem müssen auch unnötige Headerfiles immer neu geparst werden. Dies kann sehr aufwendig sein und somit die Kompilezeit nochmals verlängern.

Lumio schrieb:

//edit: bzw. warum ist es nicht gut, die Datei binary zu lesen?

Es kommt darauf an, was du genau machen willst. std::ios::binary garantiert, dass beim Lesen und Speichern die Daten nicht verändert werden. Das mag sinnvoll sein, wenn man wirklich mit binären Files arbeitet, also zum Beispiel einem JPEG. Was nämlich verändert wird, sind Dinge wie ein \n . Wenn du ein Linefeed ausgibst und auf einem Linux System bist, dann bleibt es bei einem Linefeed. Auf Windows wird aus dem Linefeed automatisch ein \r\n . Also es hat durchaus seine Vorteile, std::ios::binary nicht anzugeben, wenn man mit Textfiles arbeitet.

Aber es bleibt halt dabei, es kommt darauf an, was man eigentlich möchte. Will man das File 1:1 kopieren, dann ist std::ios::binary durchaus angebracht.

Übrigens, wurde eigentlich das Problem mit dem Crash nun behoben?

Grüssli

Ich hab den Code unter http://www.cplusplus.com/reference/iostream/istream/read/ nocheinmal gelesen und probiert. Es klappt, wenn ich ihn eins zu eins in die main-Funktion schreibe.

Wie gesagt, ich hab mir ein Ziel gesetzt, einen kleinen Parser zu basteln. Für das einlesen der Zeilen wird wohl std::ios::binary nicht wirklich benötigt.

Aber welche anderen Arten gibt es noch? Ich weiss, dass es andere Arten gibt, allerdings fallen sie mir nicht ein

Danke für eure Hilfe

Aber welche anderen Arten gibt es noch? Ich weiss, dass es andere Arten gibt, allerdings fallen sie mir nicht ein

Was verstehst du unter anderen Arten? Andere Arten von was? std::ios::binary ist ein Flag, welches man setzt oder nicht. Es gibt keine anderen Arten, es gibt höchstens andere Flags, aber keine, welche etwas in die Richtung von std::ios::binary machen.

Grüssli

Grüssli