Kopírování dat z jednoho souboru do druhého – C / C++ – Fórum – Programujte.com

Zdravím,

rozděluji jeden obří soubor na hodně malých. Vždy předem vím kolik dat načíst a přeuložit je do nového souboru. Jak to zařídit co nejrychleji v C nebo C++?

Mě napadá akorát načíst ty data do bufferu a poté je z něj zase zkopírovat do výstupního souboru. Což je min. jedno zbytečný kopírování. Já bych potřeboval něco ve smyslu input >> output s možností zvolit si velikost.

#1 PiranhaGreg
Na linuxu je na to hezká funkce, kterou bych přesně uměl využít. Raději bych ale něco ze standardních knihoven...

#2 PiranhaGreg
Data načítáš po řádcích, nebo jakým způsobem? Pokud jo, normální fstream ti nevyhovuje? By sis mohl otevřít dva soubory, původní velký a nový malý, nový otevřít přes std::ios::app a pomocí getline z velkého do malého načítat data.

Nicméně ti tady vzniká problém, že budeš muset mít uloženou pozici posledního kopírovaného řádku a k tomuto řádku se budeš muset při tvorbě dalšího kopírování do druhého malého souboru (pravděpodobně přes for cyklus) prokousat.

Možná ti toto pomůže.

#ifndef FILEHANDLER_H
#define FILEHANDLER_H

#include <fstream>
#include <string>
#include <algorithm>

class FileHandler
{
public:
	FileHandler(const std::string& fileName)
	{
		_inputFile.open(fileName.c_str());

		if (_inputFile.fail())
		{
			throw std::strerror(errno);
		}

		_lastReadLine = 1;
		_linesCount = countLines();
	}
	__int64 countLines()
	{		
		return (std::count(std::istreambuf_iterator<char>(_inputFile),
			std::istreambuf_iterator<char>(), '\n') + 1);
	}
	void ParseFile(const std::string& filename)
	{
		std::ofstream outputFile;
		outputFile.open(filename, std::ios::app);

		GotoLine(_inputFile, _lastReadLine);
		
		std::string line;
		_inputFile >> line;

		if (line != "")
		{
			outputFile << line + "\n";
		}

		++_lastReadLine;
		outputFile.close();
	}
	std::ifstream& GotoLine(std::ifstream& file, int num)
	{
		file.seekg(std::ios::beg);
		for (int i = 0; i < num - 1; ++i)
		{
			file.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
		}
		return file;
	}
	~FileHandler()
	{
		_inputFile.close();
	}
protected:
private:
	std::ifstream _inputFile;
	__int64 _linesCount;
	int _lastReadLine;
};

#endif

#3 ondrej39
Jaké řádky? O typu souboru nic nepsal, takže to může být jakýkoliv binární soubor. Řádky jsou jen v textových souborech...

#1 PiranhaGreg
Jinak než načtením do bufferu a zápisem do nového souboru (souborů) to nejde, takže nevím nad čím bádáš... Nejrychleji se to odjakživa dělo přes DMA kanál využívající buffer v RAM nezávisle na procesoru, jestli od té doby vzniklo něco ještě rychlejšího, tak snad někdo poradí...

Ukážu radši celý program, co zatím mám. Načítám data z velkého binárního souboru, který je řešen jako spoják. Já chci jednotlivé bloky ukládat do samostatných souborů 

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

typedef struct {
	char signature[8];
	uint32_t block_type;
	uint32_t block_size;
	uint32_t next;
} Block;

int main(int argc, char const * argv[]) {
	char name[3 * 9];

	if (argc != 2) {
		fprintf(stderr, "usage: %s <map>", argv[0]);
		return 1;
	}

	FILE * input = fopen(argv[1], "rb");

	while (1) {
		Block b;

		fread(&b, sizeof(b), 1, input);
		b.signature[7] = '\0';

		if (b.block_type == 0x8000)
			break;

		sprintf(name, "%s %04x %04x", b.signature, b.block_type, b.block_size);

		FILE * output = fopen(name, "wb");

		/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
		char * buffer = malloc(b.block_size);

		fread(buffer, 1, b.block_size, input);
		fwrite(buffer, 1, b.block_size, output);

		free(buffer);
		/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */

		fclose(output);
	}

	fclose(input);

	return 0;
}

Kód, který mě zajímá, jestli je takhle optimální je mezi těmi vlnovkami...

#7 PiranhaGreg
Myslím, že je zbytečné ten buffer pokaždé znovu alokovat a uvolňovat, to stačí jednou před cyklem a pak uvolnit až po jeho skončení. Jinak to vypadá v pořádku...