Wie kann ich die Liste der Dateien in einem Verzeichnis mit C oder C ++ erhalten?

https://stackoverflow.com/questions/612097

03-07-2019
|

Frage

Wie kann ich die Liste der Dateien in einem Verzeichnis in meinem C- oder C ++ - Code ermitteln?

Ich darf das nicht ausführen ls Befehl und analysieren Sie die Ergebnisse in meinem Programm.

Lösung

Bei kleinen und einfachen Aufgaben verwende ich keinen Boost, benutze ich Dirent.h Welches ist auch für Windows verfügbar:

DIR *dir;
struct dirent *ent;
if ((dir = opendir ("c:\\src\\")) != NULL) {
  /* print all the files and directories within directory */
  while ((ent = readdir (dir)) != NULL) {
    printf ("%s\n", ent->d_name);
  }
  closedir (dir);
} else {
  /* could not open directory */
  perror ("");
  return EXIT_FAILURE;
}

Es ist nur eine kleine Header-Datei und macht die meisten einfachen Dinge, die Sie benötigen, ohne einen großen vorlagenbasierten Ansatz wie Boost zu verwenden (keine Beleidigung, ich mag Boost!).

Der Autor der Windows -Kompatibilitätsschicht ist Toni Ronkko. In Unix ist es ein Standard -Header.

Update 2017:

In C ++ 17 gibt es jetzt eine offizielle Möglichkeit, Dateien Ihres Dateisystems aufzulisten: std::filesystem. Es gibt eine hervorragende Antwort von Shreevardhan unten mit diesem Quellcode:

#include <string>
#include <iostream>
#include <filesystem>
namespace fs = std::filesystem;

int main()
{
    std::string path = "/path/to/directory";
    for (const auto & entry : fs::directory_iterator(path))
        std::cout << entry.path() << std::endl;
}

Andere Tipps

C ++ 17 hat jetzt a std::filesystem::directory_iterator, was verwendet werden kann als

#include <string>
#include <iostream>
#include <filesystem>
namespace fs = std::filesystem;

int main() {
    std::string path = "/path/to/directory";
    for (const auto & entry : fs::directory_iterator(path))
        std::cout << entry.path() << std::endl;
}

Ebenfalls, std::filesystem::recursive_directory_iterator kann auch die Unterverzeichnisse iterieren.

Leider definiert der C ++ - Standard keine Standardmethode, um auf diese Weise mit Dateien und Ordnern zu arbeiten.

Da es keinen Cross -Plattform -Weg gibt, besteht die beste Cross -Plattform -Art darin, eine Bibliothek wie die zu verwenden Steigern Sie das Dateisystemmodul.

Cross -Plattform -Boost -Methode:

Die folgende Funktion, die einen Verzeichnispfad und einen Dateinamen unterliegt, sucht rekursiv das Verzeichnis und seine Unterverzeichnisse für den Dateinamen, die Rückgabe eines BOOL und falls erfolgreich den Pfad zu der gefundenen Datei.

bool find_file(const path & dir_path,         // in this directory,
               const std::string & file_name, // search for this name,
               path & path_found)             // placing path here if found
{
    if (!exists(dir_path)) 
        return false;

    directory_iterator end_itr; // default construction yields past-the-end

    for (directory_iterator itr(dir_path); itr != end_itr; ++itr)
    {
        if (is_directory(itr->status()))
        {
            if (find_file(itr->path(), file_name, path_found)) 
                return true;
        }
        else if (itr->leaf() == file_name) // see below
        {
            path_found = itr->path();
            return true;
        }
    }
    return false;
}

Quelle aus der oben genannten Boost -Seite.

Für Unix/Linux -basierte Systeme:

Sie können verwenden Opendir / Readdir / geschlossenes.

Beispielcode, der ein Verzeichnis für den Eintrag "Name" durchsucht, lautet:

len = strlen(name);
dirp = opendir(".");
while ((dp = readdir(dirp)) != NULL)
        if (dp->d_namlen == len && !strcmp(dp->d_name, name)) {
                (void)closedir(dirp);
                return FOUND;
        }
(void)closedir(dirp);
return NOT_FOUND;

Quellcode von den oben genannten Mannseiten.

Für ein Windows -basierte Systeme:

Sie können die Win32 -API verwenden Findfirstfile / FindNextfile / Findsclose Funktionen.

Das folgende C ++ - Beispiel zeigt eine minimale Verwendung von FindFirstfile.

#include <windows.h>
#include <tchar.h>
#include <stdio.h>

void _tmain(int argc, TCHAR *argv[])
{
   WIN32_FIND_DATA FindFileData;
   HANDLE hFind;

   if( argc != 2 )
   {
      _tprintf(TEXT("Usage: %s [target_file]\n"), argv[0]);
      return;
   }

   _tprintf (TEXT("Target file is %s\n"), argv[1]);
   hFind = FindFirstFile(argv[1], &FindFileData);
   if (hFind == INVALID_HANDLE_VALUE) 
   {
      printf ("FindFirstFile failed (%d)\n", GetLastError());
      return;
   } 
   else 
   {
      _tprintf (TEXT("The first file found is %s\n"), 
                FindFileData.cFileName);
      FindClose(hFind);
   }
}

Quellcode von den oben genannten MSDN -Seiten.

Eine Funktion ist ausreichend, Sie müssen keine Bibliothek der dritten Parteien verwenden (für Windows).

#include <Windows.h>

vector<string> get_all_files_names_within_folder(string folder)
{
    vector<string> names;
    string search_path = folder + "/*.*";
    WIN32_FIND_DATA fd; 
    HANDLE hFind = ::FindFirstFile(search_path.c_str(), &fd); 
    if(hFind != INVALID_HANDLE_VALUE) { 
        do { 
            // read all (real) files in current folder
            // , delete '!' read other 2 default folder . and ..
            if(! (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ) {
                names.push_back(fd.cFileName);
            }
        }while(::FindNextFile(hFind, &fd)); 
        ::FindClose(hFind); 
    } 
    return names;
}

PS: Wie von @Sebastian erwähnt, können Sie sich ändern *.* zu *.ext Um nur die Ext-Files (dh eines bestimmten Typs) in diesem Verzeichnis zu erhalten.

Für eine C Only -Lösung finden Sie dies bitte. Es erfordert nur einen zusätzlichen Kopfball:

https://github.com/cxong/tinydir

tinydir_dir dir;
tinydir_open(&dir, "/path/to/dir");

while (dir.has_next)
{
    tinydir_file file;
    tinydir_readfile(&dir, &file);

    printf("%s", file.name);
    if (file.is_dir)
    {
        printf("/");
    }
    printf("\n");

    tinydir_next(&dir);
}

tinydir_close(&dir);

Einige Vorteile gegenüber anderen Optionen:

Es ist tragbar - Wrap
Es verwendet readdir_r Wo verfügbar, was bedeutet, dass es (normalerweise) Threadsafe ist
Unterstützt Windows UTF-16 über dasselbe UNICODE Makros
Es ist C90, daher können selbst sehr alte Compiler es verwenden

Ich empfehle die Verwendung glob mit dieser wiederverwendbaren Verpackung. Es erzeugt a vector<string> entsprechend Dateipfaden, die zum Glob -Muster passen:

#include <glob.h>
#include <vector>
using std::vector;

vector<string> globVector(const string& pattern){
    glob_t glob_result;
    glob(pattern.c_str(),GLOB_TILDE,NULL,&glob_result);
    vector<string> files;
    for(unsigned int i=0;i<glob_result.gl_pathc;++i){
        files.push_back(string(glob_result.gl_pathv[i]));
    }
    globfree(&glob_result);
    return files;
}

Dies kann dann mit einem normalen System -Wildcard -Muster aufgerufen werden, wie z. B.:

vector<string> files = globVector("./*");

Hier ist ein sehr einfacher Code in C++11 Verwendung boost::filesystem Bibliothek, um Dateinamen in einem Verzeichnis zu erhalten (ohne Ordnernamen):

#include <string>
#include <iostream>
#include <boost/filesystem.hpp>
using namespace std;
using namespace boost::filesystem;

int main()
{
    path p("D:/AnyFolder");
    for (auto i = directory_iterator(p); i != directory_iterator(); i++)
    {
        if (!is_directory(i->path())) //we eliminate directories
        {
            cout << i->path().filename().string() << endl;
        }
        else
            continue;
    }
}

Ausgabe ist wie:

file1.txt
file2.dat

Warum nicht benutzen glob()?

#include <glob.h>

glob_t glob_result;
glob("/your_directory/*",GLOB_TILDE,NULL,&glob_result);
for(unsigned int i=0; i<glob_result.gl_pathc; ++i){
  cout << glob_result.gl_pathv[i] << endl;
}

Ich denke, unten Snippet kann verwendet werden, um alle Dateien aufzulisten.

#include <stdio.h>
#include <dirent.h>
#include <sys/types.h>

static void list_dir(const char *path)
{
    struct dirent *entry;
    DIR *dir = opendir(path);
    if (dir == NULL) {
        return;
    }

    while ((entry = readdir(dir)) != NULL) {
        printf("%s\n",entry->d_name);
    }

    closedir(dir);
}

Im Folgenden finden Sie die Struktur des Strukturmeingangs

struct dirent {
    ino_t d_ino; /* inode number */
    off_t d_off; /* offset to the next dirent */
    unsigned short d_reclen; /* length of this record */
    unsigned char d_type; /* type of file */
    char d_name[256]; /* filename */
};

Versuchen Sie, die X-Plattform-Methode zu steigern

http://www.boost.org/doc/libs/1_38_0/libs/filesystem/doc/index.htm

Oder verwenden Sie einfach Ihre osspezifischen Dateidaten.

Schauen Sie sich diese Klasse an, die die Win32 -API verwendet. Konstruieren Sie einfach eine Instanz, indem Sie das anbieten foldername Von worauf Sie die Auflistung wünschen, rufen Sie die an und rufen Sie die an getNextFile Methode, um die nächste zu erhalten filename aus dem Verzeichnis. Ich denke, es braucht windows.h und stdio.h.

class FileGetter{
    WIN32_FIND_DATAA found; 
    HANDLE hfind;
    char folderstar[255];       
    int chk;

public:
    FileGetter(char* folder){       
        sprintf(folderstar,"%s\\*.*",folder);
        hfind = FindFirstFileA(folderstar,&found);
        //skip .
        FindNextFileA(hfind,&found);        
    }

    int getNextFile(char* fname){
        //skips .. when called for the first time
        chk=FindNextFileA(hfind,&found);
        if (chk)
            strcpy(fname, found.cFileName);     
        return chk;
    }

};

GNU -Handbuch FTW

http://www.gnu.org/software/libc/manual/html_node/simple-directory-lister.html#simple-directory-lister

Manchmal ist es auch gut, direkt zur Quelle zu gehen (Wortspiel beabsichtigt). Sie können viel lernen, indem Sie sich die Innereien einiger der häufigsten Befehle in Linux ansehen. Ich habe einen einfachen Spiegel von GNUs Coreutils auf GitHub (zum Lesen) eingerichtet.

https://github.com/homer6/gnu_coreutils/blob/master/src/ls.c

Möglicherweise geht dies nicht mit Windows ein, aber eine Reihe von Fällen der Verwendung von UNIX -Varianten kann mithilfe dieser Methoden verwendet werden.

Ich hoffe, das hilft...

char **getKeys(char *data_dir, char* tablename, int *num_keys)
{
    char** arr = malloc(MAX_RECORDS_PER_TABLE*sizeof(char*));
int i = 0;
for (;i < MAX_RECORDS_PER_TABLE; i++)
    arr[i] = malloc( (MAX_KEY_LEN+1) * sizeof(char) );  


char *buf = (char *)malloc( (MAX_KEY_LEN+1)*sizeof(char) );
snprintf(buf, MAX_KEY_LEN+1, "%s/%s", data_dir, tablename);

DIR* tableDir = opendir(buf);
struct dirent* getInfo;

readdir(tableDir); // ignore '.'
readdir(tableDir); // ignore '..'

i = 0;
while(1)
{


    getInfo = readdir(tableDir);
    if (getInfo == 0)
        break;
    strcpy(arr[i++], getInfo->d_name);
}
*(num_keys) = i;
return arr;
}

Ich hoffe, dieser Code hilft Ihnen.

#include <windows.h>
#include <iostream>
#include <string>
#include <vector>
using namespace std;

string wchar_t2string(const wchar_t *wchar)
{
    string str = "";
    int index = 0;
    while(wchar[index] != 0)
    {
        str += (char)wchar[index];
        ++index;
    }
    return str;
}

wchar_t *string2wchar_t(const string &str)
{
    wchar_t wchar[260];
    int index = 0;
    while(index < str.size())
    {
        wchar[index] = (wchar_t)str[index];
        ++index;
    }
    wchar[index] = 0;
    return wchar;
}

vector<string> listFilesInDirectory(string directoryName)
{
    WIN32_FIND_DATA FindFileData;
    wchar_t * FileName = string2wchar_t(directoryName);
    HANDLE hFind = FindFirstFile(FileName, &FindFileData);

    vector<string> listFileNames;
    listFileNames.push_back(wchar_t2string(FindFileData.cFileName));

    while (FindNextFile(hFind, &FindFileData))
        listFileNames.push_back(wchar_t2string(FindFileData.cFileName));

    return listFileNames;
}

void main()
{
    vector<string> listFiles;
    listFiles = listFilesInDirectory("C:\\*.txt");
    for each (string str in listFiles)
        cout << str << endl;
}

Shreevardhan Antwort funktioniert großartig. Aber wenn Sie es in C ++ 14 verwenden möchten namespace fs = experimental::filesystem;

dh,,

#include <string>
#include <iostream>
#include <filesystem>

using namespace std;
namespace fs = experimental::filesystem;

int main()
{
    string path = "C:\\splits\\";
    for (auto & p : fs::directory_iterator(path))
        cout << p << endl;
    int n;
    cin >> n;
}

Diese Implementierung erkennt Ihren Zweck und füllt eine Reihe von Zeichenfolgen dynamisch mit dem Inhalt des angegebenen Verzeichnisses.

int exploreDirectory(const char *dirpath, char ***list, int *numItems) {
    struct dirent **direntList;
    int i;
    errno = 0;

    if ((*numItems = scandir(dirpath, &direntList, NULL, alphasort)) == -1)
        return errno;

    if (!((*list) = malloc(sizeof(char *) * (*numItems)))) {
        fprintf(stderr, "Error in list allocation for file list: dirpath=%s.\n", dirpath);
        exit(EXIT_FAILURE);
    }

    for (i = 0; i < *numItems; i++) {
        (*list)[i] = stringDuplication(direntList[i]->d_name);
    }

    for (i = 0; i < *numItems; i++) {
        free(direntList[i]);
    }

    free(direntList);

    return 0;
}

Das funktioniert für mich. Es tut mir leid, wenn ich mich nicht an die Quelle erinnern kann. Es ist wahrscheinlich von einer Mannseite.

#include <ftw.h>

int AnalizeDirectoryElement (const char *fpath, 
                            const struct stat *sb,
                            int tflag, 
                            struct FTW *ftwbuf) {

  if (tflag == FTW_F) {
    std::string strFileName(fpath);

    DoSomethingWith(strFileName);
  }
  return 0; 
}

void WalkDirectoryTree (const char * pchFileName) {

  int nFlags = 0;

  if (nftw(pchFileName, AnalizeDirectoryElement, 20, nFlags) == -1) {
    perror("nftw");
  }
}

int main() {
  WalkDirectoryTree("some_dir/");
}

Sie können alle direkten Dateien in Ihrem Root -Verzeichnis erhalten, indem Sie std :: experimental :: fileSystem :: Directory_iterator () verwenden. Lesen Sie dann den Namen dieser Pathfiles.

#include <iostream>
#include <filesystem>
#include <string>
#include <direct.h>
using namespace std;
namespace fs = std::experimental::filesystem;
void ShowListFile(string path)
{
for(auto &p: fs::directory_iterator(path))  /*get directory */
     cout<<p.path().filename()<<endl;   // get file name
}

int main() {

ShowListFile("C:/Users/dell/Pictures/Camera Roll/");
getchar();
return 0;
}

System nennen Sie es!

system( "dir /b /s /a-d * > file_names.txt" );

Lesen Sie dann einfach die Datei.

Bearbeiten: Diese Antwort sollte als Hack angesehen werden, aber sie funktioniert wirklich (wenn auch auf plattformspezifische Weise), wenn Sie keinen Zugriff auf elegantere Lösungen haben.

Da Dateien und Unterverzeichnisse eines Verzeichnisses im Allgemeinen in einer Baumstruktur gespeichert werden, besteht eine intuitive Möglichkeit, den DFS -Algorithmus zu verwenden, um jeden von ihnen rekursiv zu durchqueren. Hier ist ein Beispiel im Windows -Betriebssystem mit grundlegenden Dateifunktionen in IO.H. Sie können diese Funktionen in einer anderen Plattform ersetzen. Was ich ausdrücken möchte, ist, dass die Grundidee von DFS dieses Problem perfekt erfüllt.

#include<io.h>
#include<iostream.h>
#include<string>
using namespace std;

void TraverseFilesUsingDFS(const string& folder_path){
   _finddata_t file_info;
   string any_file_pattern = folder_path + "\\*";
   intptr_t handle = _findfirst(any_file_pattern.c_str(),&file_info);
   //If folder_path exsist, using any_file_pattern will find at least two files "." and "..", 
   //of which "." means current dir and ".." means parent dir
   if (handle == -1){
       cerr << "folder path not exist: " << folder_path << endl;
       exit(-1);
   }
   //iteratively check each file or sub_directory in current folder
   do{
       string file_name=file_info.name; //from char array to string
       //check whtether it is a sub direcotry or a file
       if (file_info.attrib & _A_SUBDIR){
            if (file_name != "." && file_name != ".."){
               string sub_folder_path = folder_path + "\\" + file_name;                
               TraverseFilesUsingDFS(sub_folder_path);
               cout << "a sub_folder path: " << sub_folder_path << endl;
            }
       }
       else
            cout << "file name: " << file_name << endl;
    } while (_findnext(handle, &file_info) == 0);
    //
    _findclose(handle);
}

Diese Antwort sollte für Windows -Benutzer funktionieren, die Schwierigkeiten hatten, mit Visual Studio mit einer der anderen Antworten zu arbeiten.

Laden Sie die Datei Dirent.h von der GitHub -Seite herunter. Aber es ist besser, nur die Datei Raw Dirent.h zu verwenden und meine folgenden Schritte zu befolgen (es ist so, wie ich sie zum Laufen gebracht habe).

Github -Seite für Dirent.h für Windows: Github -Seite für Dirent.h

Rohe Dirent -Datei: RAW DIRENT.H -Datei
Gehen Sie zu Ihrem Projekt und fügen Sie einen neuen Artikel hinzu (Strg+Wechsel+EIN). Fügen Sie eine Header -Datei (.h) hinzu und nennen Sie es Dirent.h.
Einfügen die RAW DIRENT.H -Datei Code in deinen Header.
Geben Sie "Dirent.h" in Ihren Code ein.

Setzen Sie das unten void filefinder() Methode in Ihrem Code und rufen Sie ihn von Ihrem an main Funktion oder bearbeiten Sie die Funktion, wie Sie sie verwenden möchten.

#include <stdio.h>
#include <string.h>
#include "dirent.h"

string path = "C:/folder"; //Put a valid path here for folder

void filefinder()
{
    DIR *directory = opendir(path.c_str());
    struct dirent *direntStruct;

    if (directory != NULL) {
        while (direntStruct = readdir(directory)) {
            printf("File Name: %s\n", direntStruct->d_name); //If you are using <stdio.h>
            //std::cout << direntStruct->d_name << std::endl; //If you are using <iostream>
        }
    }
    closedir(directory);
}

Ich habe versucht, dem Beispiel zu folgen in beide Antworten und es könnte erwähnenswert sein, dass es so aussieht wie std::filesystem::directory_entry wurde geändert, um keine Überladung der << Operator. Anstatt von std::cout << p << std::endl; Ich musste Folgendes verwenden, um es kompilieren zu können und es zum Laufen zu bringen:

#include <iostream>
#include <filesystem>
#include <string>
namespace fs = std::filesystem;

int main() {
    std::string path = "/path/to/directory";
    for(const auto& p : fs::directory_iterator(path))
        std::cout << p.path() << std::endl;
}

versuchen zu passieren p alleine alleine zu std::cout << führte zu einem fehlenden Überlastfehler.

Nur etwas, das ich teilen und mich für das Lesematerial bedanken möchte. Spielen Sie mit der Funktion für ein bisschen herum, um sie zu verstehen. Sie mögen es mögen. E stand für die Verlängerung, p ist für Pfad und S für Pfadabscheider.

Wenn der Pfad ohne Beendungsabscheider übergeben wird, wird ein Trennzeichen an den Pfad angehängt. Wenn die Erweiterung eine leere Zeichenfolge eingegeben wird, gibt die Funktion eine Datei zurück, die keine Erweiterung in ihrem Namen hat. Wenn ein einzelner Stern eingegeben wurde, werden alle Dateien im Verzeichnis zurückgegeben. Wenn die E -Länge größer als 0 ist, aber kein einzelner * ist, wird ein Punkt auf e vorbereitet, wenn E keinen Punkt an der Nullposition enthalten hat.

Für einen Rückkehrwert. Wenn eine Karte mit Nulllänge zurückgegeben wird, wurde nichts gefunden, aber das Verzeichnis war in Ordnung. Wenn der Index 999 aus dem Rückgabewert verfügbar ist, die Kartengröße jedoch nur 1 beträgt, gab dies ein Problem beim Öffnen des Verzeichnispfads.

Beachten Sie, dass diese Funktion für die Effizienz in 3 kleinere Funktionen aufgeteilt werden kann. Darüber hinaus können Sie eine Anruferfunktion erstellen, die erfasst, welche Funktion sie basierend auf der Eingabe aufrufen wird. Warum ist das effizienter? Wenn Sie alles, was eine Datei ist, nach einer Datei greifen, wird diese Methode, die zum Erstellen aller Dateien erstellt wurde, nur alle Dateien erfasst und muss nicht jedes andere unnötige Zustand bewerten, wenn sie eine Datei gefunden hat.

Dies gilt auch für beim Abnehmen von Dateien, die keine Erweiterung haben. Eine bestimmte erstellte Funktion für diesen Zweck würde nur für das Wetter bewertet, wenn das gefundene Objekt eine Datei ist und ob dann der Name der Datei einen Punkt enthält oder nicht.

Das Speichern ist möglicherweise nicht viel, wenn Sie nur Verzeichnisse mit nicht so vielen Dateien lesen. Wenn Sie jedoch eine Menge Verzeichnis lesen oder wenn das Verzeichnis ein paar Tausend Tates hat, kann dies ein großer Speicher sein.

#include <stdio.h>
#include <sys/stat.h>
#include <iostream>
#include <dirent.h>
#include <map>

std::map<int, std::string> getFile(std::string p, std::string e = "", unsigned char s = '/'){
    if ( p.size() > 0 ){
        if (p.back() != s) p += s;
    }
    if ( e.size() > 0 ){
        if ( e.at(0) != '.' && !(e.size() == 1 && e.at(0) == '*') ) e = "." + e;
    }

    DIR *dir;
    struct dirent *ent;
    struct stat sb;
    std::map<int, std::string> r = {{999, "FAILED"}};
    std::string temp;
    int f = 0;
    bool fd;

    if ( (dir = opendir(p.c_str())) != NULL ){
        r.erase (999);
        while ((ent = readdir (dir)) != NULL){
            temp = ent->d_name;
            fd = temp.find(".") != std::string::npos? true : false;
            temp = p + temp;

            if (stat(temp.c_str(), &sb) == 0 && S_ISREG(sb.st_mode)){
                if ( e.size() == 1 && e.at(0) == '*' ){
                    r[f] = temp;
                    f++;
                } else {
                    if (e.size() == 0){
                        if ( fd == false ){
                            r[f] = temp;
                            f++;
                        }
                        continue;
                    }

                    if (e.size() > temp.size()) continue;

                    if ( temp.substr(temp.size() - e.size()) == e ){
                        r[f] = temp;
                        f++;
                    }
                }
            }
        }

        closedir(dir);
        return r;
    } else {
        return r;
    }
}

void printMap(auto &m){
    for (const auto &p : m) {
        std::cout << "m[" << p.first << "] = " << p.second << std::endl;
    }
}

int main(){
    std::map<int, std::string> k = getFile("./", "");
    printMap(k);
    return 0;
}

Das hat für mich funktioniert. Es schreibt eine Datei nur mit den Namen (kein Pfad) aller Dateien. Dann liest es diese TXT -Datei und druckt sie für Sie.

void DisplayFolderContent()
    {

        system("dir /n /b * > file_names.txt");
        char ch;
        std::fstream myStream("file_names.txt", std::fstream::in);
        while (myStream.get(ch))
        {
            std::cout << ch;
        }

    }

Lizenziert unter: CC-BY-SA mit Zuschreibung

Nicht verbunden mit StackOverflow