Kontener na pliki

[moderasura]

Witam!
Potrzebuje zrobić taki kontener na pliki ale nie do końca wiem jak mam się za to zabrać O co chodzi tworze plik z nagłówkiem

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

outfile.write((char *)&"Asura    ", 8); // nagłowek pliku

i koniec pliku

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

outfile.write((char *)"\0\0\0\0", 4); // Koniec pliku

i teraz np. chce dodać jakiś plik z nagłówkiem RSFL to robię tak wczytuje ten plik i osobnym buttonem zapisuje do tego kontenera i tu jest lipa bo to bardzo toporne jest i raczej nie bedzie działać to jak powinno może bedzie ktoś w stanie podać jakieś wskazówki?

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

void __fastcall TForm2::CheckBox2Click(TObject *Sender)
{
String fileName = ExtractFilePath(ParamStr(0)) + "rsfl.bin"; // 20 bajtów nagłowek RSFL

    fstream infile;
    infile.open(fileName.c_str(), ios::in | ios::binary);

    infile.read((char *)&a, sizeof(a));

    infile.close();
}

Tu jest przykład

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

// ---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop
#include <fstream.h>

#include "stdio.h"
#include "dir.h"
#include "Unit2.h"
// ---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"

int a[6];

TForm2 *Form2;

// ---------------------------------------------------------------------------
__fastcall TForm2::TForm2(TComponent* Owner) : TForm(Owner) {
}
// ---------------------------------------------------------------------------


void __fastcall TForm2::Button2Click(TObject *Sender) {
    String fileName = ExtractFilePath(ParamStr(0)) + "mapa.pc";

     fstream outfile;


    outfile.open(fileName.c_str(), ios::out | ios::binary);

    outfile.write((char *)&"Asura    ", 8); // nagłowek pliku

    outfile.write((char *)&a, sizeof(a));

    outfile.write((char *)"\0\0\0\0", 4); // Koniec pliku

    outfile.close();

}
// ---------------------------------------------------------------------------



void __fastcall TForm2::CheckBox2Click(TObject *Sender)
{
String fileName = ExtractFilePath(ParamStr(0)) + "rsfl.bin"; // 20 bajtów nagłowek RSFL

    fstream infile;
    infile.open(fileName.c_str(), ios::in | ios::binary);

    infile.read((char *)&a, sizeof(a));

    infile.close();
}
//---------------------------------------------------------------------------
 

[polymorphism]

Zadałeś pytanie tak, że nie wiadomo, o co Tobie chodzi. Ale wracając do tego, co już jest. Po co te zera na końcu pliku? Niby jakiś znak końca? Przecież cztery zera mogą wystąpić w środku w pliku, i co wtedy? Nie przemyślałeś zupełnie sprawy. Możesz zrobić tak: każdy wpis/plik w kontenerze zaczyna się od nagłówka:

rozmiar_pliku (DWORD) dlugość_nazwy_pliku (WORD)

po tym nagłówku znajduje się nazwa pliku, a za nią sam plik. Dzięki takiej organizacji pliku będziesz w stanie iterować po zawartości kontenera. Implementacja tego jest banalnie prosta, więc powinieneś dać sobie radę.

[moderasura]

Po co te zera na końcu pliku?

Tak to jest znak końca pliku
Bez tego nie działa poprawnie plik w programie jeśli tego nie będzie pojawia sie błąd aplikacji...

Ogólnie zrobiłem tak że to wszystko działa jako tako, ale nie mam pojęcia jak zrobić by np. jak zapisuje plik do kontenera o nazwie fnfo.bin i potem chcę dopisać plik o nazwie rsfl.bin to zastępuje mi ten plik fnfo.bin a chcę zrobić tak by mi dopisywało pliki a nie zastępowało je Pewnie coś trzeba zrobić ze wskaznikami ale pytanie jak?

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

// ---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop
#include <vcl.h>
#pragma hdrstop
#include <fstream.h>

#include "stdio.h"
#include "dir.h"

#include "Unit1.h"
// ---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"


byte fnfo[20], rsfl[13500], shell[2256]  ;


TForm1 *Form1;

// ---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) {
}

// ---------------------------------------------------------------------------
void __fastcall TForm1::CheckBox1Click(TObject *Sender) {
    String fileName = ExtractFilePath(ParamStr(0)) +
        "kontener\\fnfo\\fnfo.bin"; // fnfo

    fstream infile;
    infile.open(fileName.c_str(), ios::in | ios::binary);

    infile.read((char *)&fnfo, sizeof(fnfo)); // fnfo

    infile.close();

}

// ---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender) {
    String fileName = ExtractFilePath(ParamStr(0)) + "mapa.pc";

    fstream outfile;

    outfile.open(fileName.c_str(), ios::out | ios::binary);

    outfile.write((char *)&"Asura    ", 8); // Początek pliku

    outfile.write((char *)&fnfo, sizeof(fnfo)); // fnfo

    outfile.write((char *)"\0\0\0\0", 4); //znak końca pliku

    outfile.close();
}

// ---------------------------------------------------------------------------
void __fastcall TForm1::CheckBox2Click(TObject *Sender) {
    String fileName = ExtractFilePath(ParamStr(0)) + "kontener\\rsfl\\rsfl.bin";

    fstream infile;

    infile.open(fileName.c_str(), ios::in | ios::binary);

    infile.read((char *)&rsfl, sizeof(rsfl)); // rsfl

    infile.close();
}

// ---------------------------------------------------------------------------
void __fastcall TForm1::Button2Click(TObject *Sender) {
    String fileName = ExtractFilePath(ParamStr(0)) + "mapa.pc";

    fstream outfile;

    outfile.open(fileName.c_str(), ios::out | ios::binary);

    outfile.write((char *)&"Asura    ", 8); //Początek pliku

    outfile.write((char *)&rsfl, sizeof(rsfl)); // rsfl

    outfile.write((char *)"\0\0\0\0", 4); // znak końca pliku

    outfile.close();
}

// ---------------------------------------------------------------------------
void __fastcall TForm1::CheckBox3Click(TObject *Sender) {
    String fileName = ExtractFilePath(ParamStr(0)) +"kontener\\shell\\shell.bin"; // rsfl
    fstream infile;

    infile.open(fileName.c_str(), ios::in | ios::binary);

    infile.read((char *)&shell, sizeof(shell)); // shell



    infile.close();
}

// ---------------------------------------------------------------------------
void __fastcall TForm1::Button3Click(TObject *Sender) {
    String fileName = ExtractFilePath(ParamStr(0)) + "mapa.pc";

    fstream outfile;

    outfile.open(fileName.c_str(), ios::out | ios::binary);

    outfile.write((char *)&"Asura    ", 8); // Początek pliku

    outfile.write((char *)&shell, sizeof(shell)); // shell

    outfile.write((char *)"\0\0\0\0", 4); //znak końca pliku

    outfile.close();
}
// ---------------------------------------------------------------------------

[polymorphism]

Po otwarciu strumienia musisz przesunąć wskaźnik zapisu na jego koniec. Możesz to zrobić metodą seekp lub dodając flagę ios::ate podczas otwierania strumienia.

[Cyfrowy Baron]

Swego czasu na własne potrzeby kombinowałem z wpakowywaniem pliku graficznego JPEG do pliku BMP. Jest to coś podobnego do tego co Ty próbujesz zrobić, z tą różnicą, że ja tylko umieszczałem dwa pliki w jednym. W końcu skorzystałem z innego sposobu, ale kod jeszcze mi pozostał:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

/---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------
/* W TYM ZDARZENIU NASTĘPUJE WPAKOWANIE DO PLIKU GRAFICZNEGO ZAWIERAJĄCEGO
BITMAPĘ PLIKU W FORMACIE JPEG POBRANEGO Z PLIKU kamera.jpg*/
void __fastcall TForm1::Button1Click(TObject *Sender)
{
 TMemoryStream *ms = new TMemoryStream();
 ms->Position = 0;

 ms->LoadFromFile("c:\\Bitmapa.bmp");
 ms->Position = ms->Seek(0, soFromEnd);

 char c[] = "&#182;&#182;&#182;"; // zmienna służąca do oddzielenia jednej grafiki od drugiej
 ms->Write(&c, sizeof(c));
 ms->Position = ms->Seek(0, soFromEnd) - 1;
 TMemoryStream *jpeg = new TMemoryStream();
 jpeg->LoadFromFile("c:\\kamera.jpg");
 jpeg->SaveToStream(ms);

 ms->SaveToFile("c:\\Paczka.dat");

 delete ms, jpeg;
}
//---------------------------------------------------------------------------
/* FUNKCJA WYSZUKUJĄCA MIEJSCA PODZIAŁU DWÓCH PLIKÓW. W PRZYKŁĄDZIE SĄ TO '&#182;&#182;&#182;'
 FUNKCJA ZWRACA NUMER MIEJSCA PODZIAŁU POTRZEBNY DO WYPAKOWANIA GRAFIKI*/
int FindDelimiterPos(TMemoryStream *ms, String Delimiter)
{
 int x = ms->Size;
 int pos = x + 1;
 char txt[4];
 do
 {
  pos -= 1;
  ms->Position = pos;
  ms->Read(&txt, 3);
  String tmp = (String)txt;
  if(tmp.Trim() == Delimiter.Trim()) return pos + Delimiter.Length();
 }while(ms->Position > 0);


 return 0;
}
//---------------------------------------------------------------------------

/* W PONIŻSZYM ZDARZENIU NASTĘPUJE WYPAKOWANIE DO PLIKU GRAFIKI W FORMACIE JPEG
 Z PLIKU ZAWIERAJĄCEGO BITMAPĘ*/
void __fastcall TForm1::Button2Click(TObject *Sender)
{
 TMemoryStream *ms = new TMemoryStream();
 ms->Position = 0;
 ms->LoadFromFile("c:\\Paczka.dat");
 ms->Position = 0;

 int y = FindDelimiterPos(ms, "&#182;&#182;&#182;"); // tutaj następuje pobranie pozycji w której
 Caption = y;                         // kończy się jeden plik a zaczyna drugi
 ms->Position = y;                    // o numerze pozycji decyduje ogranicznik &#182;&#182;&#182;

 int x = ms->Size;
 TMemoryStream *tmp = new TMemoryStream();
 tmp->Position = 0;
 tmp->CopyFrom(ms, x - y);
 tmp->SaveToFile("c:\\wypakowane_kamera.jpg"); // wypakowanie pliku kamera.jpg

 ms->Position = 0;
 tmp->Position  = 0;
 tmp->CopyFrom(ms, y);
 tmp->SaveToFile("c:\\wypakowane_bitmapa.bmp"); // wypakowanie pliku bitmapa.bmp

 delete ms, tmp;
}
//---------------------------------------------------------------------------

[moderasura]

Dzięki chłopaki za odpowiedz i wskazówki bardzo pomocne użyłem flagi do zapisu ios::app i zapisuje mi na końcu pliku z tym że musiałem dodać jeszcze to

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

outfile.write((char *)"\0\0\0\0", 4); // Koniec pliku

Baronie dzięki za kod który tu podałeś przerobie go na coś ala instalator na większą ilość plików


Jeszcze takie małe pytanko trochę wstyd o to pytać ale łba nikt nie urwie chyba
moje pytanie brzmi ?... Wczytuje plik w moim programie, oczywiście plik już istnieje i znam rozmiar w bajtach tego pliku i wszystko cacy, wczytuje plik zapisuje ilość bajtów się zgadza. Ale jak utworzyć strukturę by wczytać plik dowolnego rozmiaru w bajtach i potem to zapisać tak by wszystko grało ? Są do tego jakieś proste metody czy to bardziej skomplikowane?

odczyt z pliku

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

void __fastcall TForm1::CheckBox20Click(TObject *Sender)
{
 
byte plik[172];                                                            

String fileName = ExtractFilePath(ParamStr(0)) +"kontener\\172\\172.bin";

    fstream infile;

    infile.open(fileName.c_str(), ios::in | ios::binary);

    infile.read((char *)&plik, sizeof(plik));
 
    infile.close();
}
 

Zapis do pliku

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

void __fastcall TForm1::Button4Click(TObject *Sender) {
   
byte plik[172];                                                            
 
String fileName = ExtractFilePath(ParamStr(0)) + "kontener\\gotowy.bin";

    fstream outfile;

    outfile.open(fileName.c_str(), ios::out | ios::app | ios::binary);

    outfile.write((char *)&plik, sizeof(plik));
 
    outfile.close();
}
 

Nie wiem dlaczego ale nie koloruje mi składni

// dlatego, bo do kolorowania składni jest znacznik CPP, a nie CODE.

[moderasura]

Odświeżam Temat

[Cyfrowy Baron]

Zadane przez Ciebie pytania są dla mnie osobiście mało zrozumiałe.

[polymorphism]

Jeśli chodzi Ci o czytanie ze strumienia ifstream, to możesz czytać plik do momentu, gdy metoda gcount zwróci zero. Jeśli chcesz poznać wielkość pliku, wtedy:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

size_t size = is.seekg(0, ios::end).tellg();
is.seekg(0);

[Cyfrowy Baron]

Ale jak utworzyć strukturę by wczytać plik dowolnego rozmiaru w bajtach i potem to zapisać tak by wszystko grało ?

W kwestii struktury, bo reszty nie rozumiem. Struktura musi mieć z góry ustalony rozmiar, więc zapisując strukturę do pliku zawsze otrzymasz plik o rozmiarze równym strukturze i nie wczytasz do struktury pliku większego niż ustalony rozmiar struktury. Pisząc o strukturze mam oczywiście na myśli typ struct.

[polymorphism]

Jemu chyba chodzi o bufor, do którego mógłby wczytać plik, a następnie zapisać go w inne miejsce (ów kontener?). W sumie jeśli chodzi o przepisywanie pliku, to bufor może być jakiejkolwiek wielkości, bo przecież nie trzeba od razu wczytywać całego pliku do pamięci, można to zrobić fragmentami.

[Cyfrowy Baron]

Wciąż nie do końca to rozumiem, ale skoro plik ma być tylko przepisywany to czy nie prościej posłużyć się klasą TMemoryStream, operacje zostaną wykonane w pamięci?!

[polymorphism]

Jeśli miałby być przepisywany z pliku do pliku, to nie, byłoby to nieefektywne. Strumień pamięciowy byłby dobry wtedy, gdy chciałbyś coś montować w całości w pamięci.

Oczywiście zamiast standardowych strumieni plikowych, można użyć VCL-owych wersji, np. TFileStream.

[moderasura]

Chodzi mi ogólnie o to ze mam określona liczę plików o różnych rozmiarach w bajtach... i teraz tak np. mam plik (72 bajty) to z tym odczytem i zapisem nie mem problemów dlatego ze znam jego rozmiar...Problem polega na tym ze chce wczytać oraz zapisać o różnych rozmiarach plików w bajtach lub KB, MB, itd..

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

// ---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop
#pragma hdrstop
#include <fstream.h>
#include "stdio.h"
#include "dir.h"
#include <memory>

#include "Unit1.h"
#include "Unit1.h"
// ---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"

byte fnfo[20];

TForm1 *Form1;

// ---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) {
}

// ---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender) {
    String fileName = ExtractFilePath(ParamStr(0)) + "kontener\\fnfo\\fnfo.bin";

    fstream infile;

    infile.open(fileName.c_str(), ios::in | ios::binary);

    infile.read((char *)&fnfo, sizeof(fnfo));

    infile.close();
}

// ---------------------------------------------------------------------------
void __fastcall TForm1::Button2Click(TObject *Sender) {
    String fileName = ExtractFilePath(ParamStr(0)) + "Environments\\mp_01a.pc";

    fstream outfile;

    outfile.open(fileName.c_str(), ios::out | ios::app | ios::binary);

    outfile.write((char *)&fnfo, sizeof(fnfo));

    ;

    outfile.close();
}
// ---------------------------------------------------------------------------

Wiem ze ciężko wam zrozumieć moje pytania bo nie potrafię tego dokładnie sprecyzować ...Znam już funkcje odczytu i zapisu w pliku tzw...kontener ale nie moge sobie poradzić z plikami o dowolnym rozmiarze pliku...Tzn.Mam jakiś tam plik ale nie znam jego rozmiaru i chce tak zrobić by program go wpakował do bufora i potem z tego bufora go zapisał w innym pliku

[moderasura]

Jemu chyba chodzi o bufor, do którego mógłby wczytać plik, a następnie zapisać go w inne miejsce (ów kontener?). W sumie jeśli chodzi o przepisywanie pliku, to bufor może być jakiejkolwiek wielkości, bo przecież nie trzeba od razu wczytywać całego pliku do pamięci, można to zrobić fragmentami.

To miałem na mysli