Divisor de archivos [C/C++]

Divisor de archivos [C/C++]

Pues estuve siguiendo con C++ y me encontre con una función muy interesante en fstream, que es la posibilidad de hacer una especie de "divisor de archivos" metí la posibilidad de darle otra extensión al archivo dividido.

Pongo el code y lo explico luego:

#include <iostream>
#include <fstream>
#include <windows.h> //usalo si vas  a usar el GetFileAtributes
using namespace std;
char FileName[MAX_PATH] = "",ext[5] = "",archivo2[] = "",bytes[20][10000000];
int Num,tam,posicionmemoria = 0,sizeyadividido;
int main(void)
{
cout << "\nEscribe un archivo existente: ";
    cin.getline(FileName, MAX_PATH);
    if(GetFileAttributes(FileName) ==  0xFFFFFFFF)
    {
    cout << "\nArchivo erroneo";
    cin.get();
    return 0;
    }
    cout << "\nEscribe una extension: ";
    cin.getline(ext, MAX_PATH);
    cout << "\nSeparaciones(+2): ";
    cin >> Num;
if(Num < 2)
{
cout << "\nError,no se puede separar el archivo en "<<Num<<"parte/s";
cin.get();
return 0;
}



ifstream IFile(FileName, ios::binary);
IFile.seekg(0, ios::end);
tam = IFile.tellg();
sizeyadividido = tam / Num;
IFile.seekg(0, ios::beg);
for(int i = 0; i< Num; i++)
IFile.read(bytes[i], sizeyadividido);
IFile.close();
for(int i = 0; i < Num; i++)
{
sprintf(archivo2, "%d_%s.%s", i, FileName, ext);
ofstream OFile(archivo2, ios::binary);
OFile.write(bytes[i], sizeyadividido);
OFile.close();
}
cout << "\n"<< FileName << " se dividio en  " << Num << " archivos";
cin.get();
return EXIT_SUCCESS;
}

Primero declaramos todas las variables, librerías y demás.
Ponemos el nombre y extensión de un archivo que este EN EL MISMO LUGAR que nuestro ejecutable.

Entonces tenemos la función GetFileAtributes que nos dice si existe o no y si tiene los atributos suficientes para poder dividirlo.

¿Por qué 0xFFFFFFFF?

Porque si la función falla el valor de retorno es 0xFFFFFFFF o INVALID_FILE_ATTRIBUTES cosa que nos permite saber lo anteriormente comentado.

Luego se le implementa la extensión y el numero de partes,(lógicamente tiene que ser mayor de dos)

Y luego ya empieza el codigo verdadero comienza a leer los bytes del archivo y divide su tamaño por las partes que hemos pedido y con eso le damos el valor a sizeyadividido que en realidad serian los bytes por parte.

Llega el primer for con el que se lee todo el code y en el segundo se escribe todo(extensión, nombre,  contenido, bytes) hasta for(int i = 0; i < Num; i++) sencillo,¿no?

ScreenShot en C

El code no es mio, lo encontré en Internet, y como a mi me ha servido, quizás a vosotros también os sirva.

El uso es muy simple, creas un nuevo proyecto y agregas la librería "captura.h" y el "main.cpp".

Es importante saber nuestra resolución de pantalla, para poder modificar correctamente esta instrucción:

CapturaPantalla(0,0,800,600,name);

captura.h

Código:

PBITMAPINFO CreateBitmapInfoStructure(HBITMAP hBmp)
{
BITMAP bmp;
PBITMAPINFO pbmi;
WORD cClrBits;

//obtiene la altura, anchura, y profundidad del color de la imagen
if(!GetObject(hBmp,sizeof(BITMAP),(LPSTR)&bmp))return NULL;

cClrBits = 24;

/*
reserva la memoria para la estructura PBITMAPINFO, que contendrá la informacion
de la cabecera
*/
if(cClrBits!=24)
pbmi=(PBITMAPINFO)LocalAlloc(LPTR,sizeof(BITMAPINFOHEADER)+sizeof(RGBQUAD)*(1<<cClrBits));
else
pbmi=(PBITMAPINFO)LocalAlloc(LPTR,sizeof(BITMAPINFOHEADER));

//inicializa la estructura
pbmi->bmiHeader.biSize = sizeof( BITMAPINFOHEADER );
pbmi->bmiHeader.biWidth = bmp.bmWidth;
pbmi->bmiHeader.biHeight = bmp.bmHeight;
pbmi->bmiHeader.biPlanes = bmp.bmPlanes;
pbmi->bmiHeader.biBitCount = 24;

if(cClrBits<24)pbmi->bmiHeader.biClrUsed=(1<<cClrBits);

pbmi->bmiHeader.biCompression = BI_RGB;
pbmi->bmiHeader.biSizeImage=(pbmi->bmiHeader.biWidth+7)/8*pbmi->bmiHeader.biHeight*cClrBits;
pbmi->bmiHeader.biClrImportant = 0;

return pbmi;
}

HRESULT SaveBitmap(char strFileName[128],PBITMAPINFO pbi,HBITMAP hBMP,HDC hDC)
{
HRESULT hr = E_FAIL;
HANDLE hf; // file handle
BITMAPFILEHEADER hdr; // bitmap file-header
PBITMAPINFOHEADER pbih; // bitmap info-header
LPBYTE lpBits; // memorypointer
DWORD dwTotal; // total count of bytes
DWORD cb; // incremental count of bytes
BYTE *hp; // byte pointer
DWORD dwTmp; // temp-variable


if(pbi==NULL)return E_FAIL;

pbih=(PBITMAPINFOHEADER)pbi;
lpBits=(LPBYTE)GlobalAlloc(GMEM_FIXED,pbih->biSizeImage);

if(!lpBits)return E_FAIL;

if(!GetDIBits(hDC,hBMP,0,(WORD)pbih->biHeight,lpBits,pbi,DIB_RGB_COLORS))return E_FAIL;

//crea el .bmp
hf=CreateFile(strFileName,GENERIC_READ|GENERIC_WRITE,(DWORD)0,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,(HANDLE)NULL);

if(hf==INVALID_HANDLE_VALUE)return E_FAIL;

hdr.bfType = 0x4D42; // 0x42 = "B", 0x4D = "M"


hdr.bfSize=(DWORD)(sizeof(BITMAPFILEHEADER)+pbih->biSize+pbih->biClrUsed*sizeof(RGBQUAD)+pbih->biSizeImage);
hdr.bfReserved1=0;
hdr.bfReserved2=0;

hdr.bfOffBits=(DWORD)sizeof(BITMAPFILEHEADER)+pbih->biSize+pbih->biClrUsed*sizeof(RGBQUAD);


if(!WriteFile(hf,(LPVOID)&hdr,sizeof(BITMAPFILEHEADER),(LPDWORD)&dwTmp,NULL))return E_FAIL;

if(!WriteFile(hf,(LPVOID)pbih,sizeof(BITMAPINFOHEADER)+pbih->biClrUsed*sizeof(RGBQUAD),(LPDWORD)&dwTmp,(NULL)))return E_FAIL;


dwTotal=cb=pbih->biSizeImage;
hp=lpBits;

if(!WriteFile(hf,(LPSTR)hp,(int)cb,(LPDWORD)&dwTmp,NULL))return E_FAIL;
if(!CloseHandle(hf))return E_FAIL;

GlobalFree((HGLOBAL)lpBits);

return S_OK;
}

/*
uso: CapturaPantalla(posicion_inicial_x,posicion_inicial_y,posicion_final_x,posicion_final_y);
*/

void CapturaPantalla(unsigned int Ax,unsigned int Ay,unsigned int Bx,unsigned int By,char *Ruta)
{
BYTE *mem;
int bpp,c;
    HWND HwndSrc;
    HDC HdcSrc;
    HDC HdcMemory;
    HDC HdcStrech;
    HBITMAP Hbmp;
    HBITMAP HbmpStrech;
    HBITMAP HbmpPrev;
    HBITMAP HbmpPrevStrech;
    HBITMAP BmpPrueba;

HwndSrc=GetDesktopWindow();                               //almacena el manejador del escritorio
    HdcSrc=GetWindowDC(HwndSrc);                               //se obtiene el DC del escritorio
HdcMemory=CreateCompatibleDC(HdcSrc);                      //se crea una copia del DC del escritorio
HdcStrech=CreateCompatibleDC(HdcSrc);                   //Cd que almacenara la imagen pequeña
Hbmp=CreateCompatibleBitmap(HdcSrc,1024,768);          //se cra un bitmap del DC del escritorio
HbmpStrech=CreateCompatibleBitmap(HdcSrc,Bx-Ax,By-Ay);  //bitmap que almacenara el Strech
HbmpPrev=(HBITMAP)SelectObject(HdcMemory,Hbmp);        //se asocia el bitmap con el DC
HbmpPrevStrech=(HBITMAP)SelectObject(HdcStrech,HbmpStrech);

BitBlt(HdcMemory,0,0,800,600,HdcSrc,Ax,Ay,SRCCOPY);
    StretchBlt(HdcStrech,0,0,800,600,HdcMemory,0,0,800,600,SRCCOPY);
    HbmpStrech=(HBITMAP)SelectObject(HdcStrech,HbmpPrevStrech);
    Hbmp=(HBITMAP)SelectObject(HdcMemory,HbmpPrev);

bpp=800*600*8;

c=GetBitmapBits(HbmpStrech,0,0);
mem=(BYTE*)malloc((c-1)*sizeof(BYTE*));
memset(mem,0,sizeof(mem));

    GetBitmapBits(HbmpStrech,c,mem);
BmpPrueba = CreateCompatibleBitmap(HdcSrc,Bx-Ax,By-Ay);
SetBitmapBits(BmpPrueba,c,mem);
SaveBitmap(Ruta,CreateBitmapInfoStructure(BmpPrueba),BmpPrueba,HdcSrc);

    DeleteDC(HdcSrc);
    DeleteDC(HdcMemory);
    DeleteDC(HdcStrech);
    DeleteObject(Hbmp);
    DeleteObject(HbmpPrev);
    DeleteObject(HbmpStrech);
    DeleteObject(HbmpPrevStrech);

return;
}

main.cpp

Código:

#include <windows.h>
#include <iostream>
#include "captura.h"

using namespace std;

int main(int argc, char *argv[])
{
    char name[15];
    for(int i=0;i<10;i++)
    {
            name[0]='\0';
            strcat(name,"D:\\");
            char n[2];
            n[0]='\0';
            sprintf(n,"%i",i);
            strcat(name,n);
            strcat(name,".jpg");
    CapturaPantalla(0,0,800,600,name);
 Sleep(1000);
}
    system("PAUSE");
    return EXIT_SUCCESS;
}