C ++ file packaging tool implementation

Let's write a packaging tool. Many of them are found on the network, but I just merged the changes.

// Packetfile. cpp: defines the entry point of the console application.

# Include "stdafx. H"
# Include "serchallfile. H"
# Include "mycab. H"

Int _ tmain (INT argc, _ tchar * argv [])
{
Vector <string> vec_file;
Vector <string >:: iterator itemfilename;
Char filepacketpath [max_path] = "E: \ huangyushi \ Test Written instance ";
Char fileputpath [max_path] = "D: \ fasdfasdf \ My. Cab ";
Cserchallfile: getinstance ()-> get_filelist (filepacketpath, vec_file );

// -------------------- Packaging process --------------------
// Declare the object
Cmycab MC;
// Set the output file
MC. setoutputfile (fileputpath );
// Add the file to be packaged
For (itemfilename = vec_file.begin (); itemfilename <vec_file.end (); itemfilename ++)
{
MC. AddFile (* itemfilename). c_str ());
}
// Perform Packaging
MC. domakecab ();

// -------------------- Solution Process --------------------
// Declare the object
Cmycab UMC;
// Unpackage
UMC. douncab (fileputpath );

Cin. Clear ();
Cin. Get ();

Return 0;

}

Bytes -----------------------------------------------------------------------------------------------------------------------

To package the files under a file, all I need to do is traverse the files in the file and record all the files (through get_filelist () we can get the corresponding file path and save it to a vector)

# Pragma once

# Include <string>
# Include <vector>
# Include <fstream>
# Include <windows. h>
# Include <iostream>
# Include <conio. h>

Using namespace STD;

Class cserchallfile
{
Public:
Cserchallfile (void );
~ Cserchallfile (void );
Static cserchallfile * getinstance ();

Public:
/* Void find (char * lppath );
Void _ Find (string path );*/

Void get_filelist (char * foldname, vector <string> & filelist );
Void readfile (const char * filename );
Void writefile (string filename );
};

# Include "stdafx. H"
# Include "serchallfile. H"

Static cserchallfile * instance;

Cserchallfile: cserchallfile (void)
{
}

Cserchallfile ::~ Cserchallfile (void)
{
}

Cserchallfile * cserchallfile: getinstance ()
{
If (instance = NULL)
{
Instance = new cserchallfile ();
}

Return instance;
}

// Traverse the list of file names under a folder (including nested folders)
Void cserchallfile: get_filelist (char * foldname, vector <string> & filelist)
{
Handle hfind;
Win32_find_data filedata;
String line;
Char FN [max_path];
Char tmpfn [max_path];
Strcpy (FN, foldname );

// Process the string of the folder name
If (FN [strlen (FN)-1]! = '\\')
{
Strcat (FN ,"\\");
}

// Pay attention to the order. At this time, FN has been added "\\"
Strcpy (tmpfn, FN );
// If this parameter is not added, an error occurs!
Strcat (FN ,"*");

Hfind = findfirstfile (FN, & filedata );
Findnextfile (hfind, & filedata );
While (findnextfile (hfind, & filedata ))
{
// If the scan result is a folder
If (filedata. dwfileattributes & file_attribute_directory)
{
If (filedata. cfilename [0]! = '.')
{
Char szfile [max_path];
Strcpy (szfile, tmpfn );
Strcat (szfile, filedata. cfilename );
Get_filelist (szfile, filelist );
}
}
// Scan the file
Else
{
Line = (string) tmpfn;
Line + = filedata. cfilename;
/* If (line. Find (". H", 0 )! = String: NPOs)
{
Filelist. push_back (line );
}
Else
{
Continue;
}*/
Filelist. push_back (line );
}
// Cout <line <Endl;
}
}

Bytes ---------------------------------------------------------------------------------------------------------------------

# Pragma once

# Include <iostream>
# Include <stdio. h>
# Include <stdlib. h>
# Include <memory. h>
# Include <string. h>
# Include <error. h>
# Include <direct. h>
Using namespace STD;

// Maximum number of packaged files
# Define max_file_count 1024
// Maximum path character Length
# Define max_path 260

// File Header
Struct filehead
{
Unsigned int filecount; // number of files
Unsigned int filelen [max_file_count]; // File Size
Char filename [max_file_count] [max_path]; // file name
};

Class cmycab
{
PRIVATE:
Filehead FH; // File Header
Char objectfilepathname [max_path]; // generate the location and name of the package file

Public:
Cmycab (void );
~ Cmycab (void );

// Add a file to the package
Void AddFile (const char * filepathname );
// Set the packaging output file
Void setoutputfile (char * OUTFILE );
// Get the file size (Pass in the file pointer opened in binary mode)
Long getfilesize (File * PF );
// Create a packaging File
Void domakecab ();
// Unpackage (to save time and avoid writing error handling, you can add it as needed)
Void douncab (char * cabfilepathname );

PRIVATE:
// Display package file information
Void printcab ();
// Create a folder
Void checktargetpath (string targetpath );
};

# Include "stdafx. H"
# Include "mycab. H"

Cmycab: cmycab (void)
{
Memset (& FH, 0x0, sizeof (FH ));
Memset (objectfilepathname, 0x0, sizeof (objectfilepathname ));
}

Cmycab ::~ Cmycab (void)
{
}

// Add a file to the package
Void cmycab: AddFile (const char * filepathname)
{
If (FH. filecount> = max_file_count-1)
{
Cout <"supports up to" <max_file_count <"Files" <Endl;
Return;
}
Strcpy (FH. filename [FH. filecount], filepathname );
FH. filecount ++;
}

// Set the packaging output file
Void cmycab: setoutputfile (char * OUTFILE)
{
Memset (objectfilepathname, 0x0, sizeof (objectfilepathname ));
Strcpy (objectfilepathname, OUTFILE );
}

// Get the file size (Pass in the file pointer opened in binary mode)
Long cmycab: getfilesize (File * PF)
{
// Move the pointer to the end of the file
Fseek (PF, 0,/* seek_end */2 );
Return ftell (PF );
}

// Create a packaging File
Void cmycab: domakecab ()
{
If (FH. filecount <1)
{
Cout <"no file added to packaging" <Endl;
Return;
}
If (strlen (objectfilepathname) <1)
{
Cout <"the output location of the package file is not specified" <Endl;
Return;
}

File * poutfile = NULL;
File * pworkfile = NULL;

// Obtain the size of all objects
For (INT I = 0; I <FH. filecount; I ++)
{
Pworkfile = fopen (FH. filename [I], "rb ");
If (null = pworkfile)
{
Cout <"file:" <FH. filename [I] <"cannot read [" <strerror (errno) <"]" <Endl;
Return;
}
FH. filelen [I] = getfilesize (pworkfile );
Fclose (pworkfile );
}

// Check whether a folder exists
Checktargetpath (objectfilepathname );
// Start to merge and write files
Poutfile = fopen (objectfilepathname, "WB ");
If (null = poutfile)
{
Cout <"failed to create output file [" <strerror (errno) <"]" <Endl;
Return;
}

// Write the file header
Fwrite (& FH, sizeof (FH), 1, poutfile );
// Write each file
For (INT I = 0; I <FH. filecount; I ++)
{
Unsigned char * ptmpdata = NULL;
Pworkfile = fopen (FH. filename [I], "rb ");
If (null = pworkfile)
{
Cout <"file:" <FH. filename [I] <"cannot read [" <strerror (errno) <"]" <Endl;
Fclose (pworkfile );
Fclose (poutfile );
Return;
}
Ptmpdata = new unsigned char [FH. filelen [I];
Fread (ptmpdata, FH. filelen [I], 1, pworkfile );
If (ferror (pworkfile ))
{
Cout <"file:" <FH. filename [I] <"cannot read [" <strerror (errno) <"]" <Endl;
Fclose (pworkfile );
Fclose (poutfile );
Return;
}
Fwrite (ptmpdata, FH. filelen [I], 1, poutfile );
If (ferror (poutfile ))
{
Cout <"file:" <objectfilepathname <"cannot be written to [" <strerror (errno) <"]" <Endl;
Fclose (pworkfile );
Fclose (poutfile );
Return;
}
Delete [] ptmpdata;
Fclose (pworkfile );
}

Fclose (poutfile );
Cout <"package completed" <Endl;
}

// Unpackage (to save time and avoid writing error handling, you can add it as needed)
Void cmycab: douncab (char * cabfilepathname)
{
File * pcab = NULL;
File * pwork = NULL;

Pcab = fopen (cabfilepathname, "rb ");

// Read the file header
Memset (& FH, 0x0, sizeof (FH ));
Fread (& FH, sizeof (FH), 1, pcab );

Printcab ();

// Put all files to the current directory.
For (INT I = 0; I <FH. filecount; I ++)
{
Unsigned char * ptmpdata = NULL;
Ptmpdata = new unsigned char [FH. filelen [I];
Fread (ptmpdata, FH. filelen [I], 1, pcab );
// Only get the file name. Do not generate the file path name.
Char tmpfilename [max_path];
String STR = "e :\\ huangyushi \ Test Written instance \\";
String AAA;
AAA. Assign (FH. filename [I], strlen (FH. filename [I]);
Const char * chaaaaa = aaa. Replace (0, str. Length (), "\"). c_str ();
Char ptmpc [max_path];
Strcpy (ptmpc, chaaaaa );

Memset (tmpfilename, 0x0, sizeof (tmpfilename ));
Strcpy (tmpfilename, ptmpc + 1 );
// Obtain the path of the cab file
Char tmppathname [max_path];
Memset (tmppathname, 0x0, sizeof (tmppathname ));
Strcpy (tmppathname, cabfilepathname );
Char * tnmpc = tmppathname + strlen (tmppathname );
While ('\\'! = * Tmpc)
{
Tmpc --;
}
Tmpc ++;
* Tmpc = '\ 0 ';
Strcat (tmppathname, tmpfilename );

Pwork = fopen (tmppathname, "WB ");
If (pwork = NULL)
{
Checktargetpath (tmppathname );
Pwork = fopen (tmppathname, "WB ");
}
Fwrite (ptmpdata, FH. filelen [I], 1, pwork );
Fclose (pwork );
Delete [] ptmpdata;
}

Fclose (pcab );
}

// Display package file information
Void cmycab: printcab ()
{
Cout <"File Information:" <Endl;
Cout <"Total number of files:" <FH. filecount <Endl;
For (INT I = 0; I <FH. filecount; I ++)
{
Cout <FH. filename [I] <"\ t" <FH. filelen [I] <"Byte" <Endl;
}
}

// Create a folder
Void cmycab: checktargetpath (string targetpath)
{
// Log & log = Log: getlog ("Main", "checktargetpath ");
Int e_pos = targetpath. Length ();
Int f_pos = targetpath. Find ("\", 0 );
String subdir;
Do
{
E_pos = targetpath. Find ("\", f_pos + 2 );
If (e_pos! =-1)
{
Subdir = targetpath. substr (0, e_pos );
If (_ mkdir (subdir. c_str () = 0)
Printf ("creat success % s", subdir. c_str ());
Else
Printf ("creat fail % s", subdir. c_str ());
}
F_pos = e_pos;
} While (f_pos! =-1 );
}