#include <fstream>
#include <vector>

int main()
{
    std::ifstream f("test.txt", std::ios::in | std::ios::binary);

    if( !f )
        return 1;

    std::vector<char> buffer;
    std::ifstream::pos_type size = 0;

    if( f.seekg(0, std::ios::end) )
    {
       size = f.tellg();
    }

    if( size && f.seekg(0, std::ios::beg) )
    {
       buffer.resize(size);
       f.read(&buffer[0], size);
    }
    
    return 0;
}

ifstream inputFile("filename.txt");
vector<char> filedata( ( istreambuf_iterator<char>( inputFile ) ), istreambuf_iterator<char>() );

    std::vector<char> buf;
    std::ifstream inputFile("name.txt");
    std::copy(std::istreambuf_iterator<char>(inputFile),
             std::istreambuf_iterator<char>(),
    std::back_inserter(buf));

OE>ifstream inputFile("filename.txt");
OE>vector<char> filedata( ( istreambuf_iterator<char>( inputFile ) ), istreambuf_iterator<char>() );
OE>

example.cpp
D:\WORK\test2\example.cpp(846) : error C2664: '__thiscall std::vector<char,class std::allocator<char> >::std::vector<char,class std::allocator<char> >(unsigned int,const char &,const class std::allocator<char> &)' : cannot convert parameter 1 from '
class std::istreambuf_iterator<char,struct std::char_traits<char> >' to 'unsigned int'
No user-defined-conversion operator available that can perform this conversion, or the operator cannot be called

// file2vect.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <Windows.h>
#include <vector>
#include <iostream>
#include <fstream>

using namespace std;

int _tmain( int argc, _TCHAR* argv[] )
{
    DWORD t1 = GetTickCount();

    ifstream inputFile( "E:\\PROJECTS\\VC71\\tests\\file2vect\\filename.txt", ios::in | ios::binary );

    if( !inputFile )
    {
        cout << "file open error!!!" << endl;
        return 1;
    }

    vector<char> filedata( ( istreambuf_iterator<char>( inputFile ) ),  istreambuf_iterator<char>() );

    DWORD t2 = GetTickCount();

    cout<< "vector size = " << filedata.size() << ", loading time  = " << t2 - t1 << " ms." << endl;

    return 0;
}

vector size = 2027953, loading time  = 211 ms.
vector size = 2027953, loading time  = 210 ms.
vector size = 2027953, loading time  = 210 ms.
vector size = 2027953, loading time  = 211 ms.

// file2vect2.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <windows.h>
#include <iostream>
#include <fstream>
#include <vector>
#include <time.h>

using namespace std;

int main()
{
    DWORD t1 = GetTickCount();

    std::ifstream f("E:\\PROJECTS\\VC71\\tests\\file2vect\\filename.txt", std::ios::in | std::ios::binary);

    if( !f )
    {
        cout << "file open error!!!" << endl;
        return 1;
    }

    std::vector<char> buffer;
    std::ifstream::pos_type size = 0;

    if( f.seekg(0, std::ios::end) )
    {
       size = f.tellg();
    }

    if( size && f.seekg(0, std::ios::beg) )
    {
       buffer.resize(size);
       f.read(&buffer[0], size);
    }
    
    DWORD t2 = GetTickCount();

    cout<< "vector size = " << buffer.size() << ", loading time  = " << t2 - t1 << " ms." << endl;

    return 0;
}

vector size = 2027953, loading time  = 20 ms.
vector size = 2027953, loading time  = 10 ms.
vector size = 2027953, loading time  = 20 ms.
vector size = 2027953, loading time  = 10 ms.

E:\PROJECTS\VC71\tests\file2vect\file2vect\Release\file2vect.exe
vector size = 322525944, loading time  = 88187 ms.

E:\PROJECTS\VC71\tests\file2vect\file2vect2\Release\file2vect2.exe
vector size = 322525944, loading time  = 37514 ms.

pos_type tellg();
basic_istream& seekg(pos_type pos);
basic_istream& seekg(off_type off, ios_base::seek_dir way);

OE>>    vector<char> filedata( ( istreambuf_iterator<char>( inputFile ) ),  istreambuf_iterator<char>() );

   filedata.assign( ( istreambuf_iterator<char>( inputFile ) ),  istreambuf_iterator<char>() );

   filedata.insert( filedata.begin(), ( istreambuf_iterator<char>( inputFile ) ),  istreambuf_iterator<char>() );

#include <iostream>


std::istream::pos_type probe(std::istream &stream)
{
    std::istream::pos_type oldpos = stream.tellg();
    std::istream::pos_type size = 0;

    if( stream.seekg(0, std::ios::end) )
       size = stream.tellg();

    stream.seekg(oldpos, std::ios::beg);

    return size;
}    
    

int main()
{
    std::cout << probe(std::cin);
    return 0;
}

std::vector<char> v;
v.reserve(1000000);
std::copy((istreambuf_iterator<char>( inputFile )),  istreambuf_iterator<char>(), std::back_inserter(v));

OE>// file2vect2.cpp : Defines the entry point for the console application.
OE>//

OE>#include "stdafx.h"
OE>#include <windows.h>
OE>#include <iostream>
OE>#include <fstream>
OE>#include <vector>
OE>#include <time.h>

OE>using namespace std;

OE>int main()
OE>{
OE>    DWORD t1 = GetTickCount();

OE>    std::ifstream f("E:\\PROJECTS\\VC71\\tests\\file2vect\\filename.txt", std::ios::in | std::ios::binary);

OE>    if( !f )
OE>    {
OE>        cout << "file open error!!!" << endl;
OE>        return 1;
OE>    }

OE>    std::vector<char> buffer;
OE>    std::ifstream::pos_type size = 0;

OE>    if( f.seekg(0, std::ios::end) )
OE>    {
OE>       size = f.tellg();
OE>    }

OE>    if( size && f.seekg(0, std::ios::beg) )
OE>    {
OE>       buffer.resize(size);
OE>       f.read(&buffer[0], size);
OE>    }
    
OE>    DWORD t2 = GetTickCount();

OE>    cout<< "vector size = " << buffer.size() << ", loading time  = " << t2 - t1 << " ms." << endl;

OE>    return 0;
OE>}
OE>

OE>vector size = 2027953, loading time  = 20 ms.
OE>vector size = 2027953, loading time  = 10 ms.
OE>vector size = 2027953, loading time  = 20 ms.
OE>vector size = 2027953, loading time  = 10 ms.
OE>

OE>с чем вас и поздравляю

OE>E:\PROJECTS\VC71\tests\file2vect\file2vect\Release\file2vect.exe
OE>vector size = 322525944, loading time  = 88187 ms.

OE>E:\PROJECTS\VC71\tests\file2vect\file2vect2\Release\file2vect2.exe
OE>vector size = 322525944, loading time  = 37514 ms.
OE>

#define UNICODE
#include <stdio.h>
#include <windows.h>

main()
{
    DWORD t1 = GetTickCount();
    
    HANDLE hFile = CreateFile(TEXT("file.bin"), 
                              GENERIC_READ,
                              0,
                              NULL,
                              OPEN_EXISTING,
                              0,
                              0);
    
    if (hFile == INVALID_HANDLE_VALUE)
    {
        printf("Error: CreateFile = INVALID_HANDLE_VALUE\n");
        return;
    }
    
    LPVOID buf = 0;
    DWORD size = 0;
    DWORD dw;
    
    size = GetFileSize(hFile, NULL);
    
    buf = HeapAlloc(GetProcessHeap(), 0, size);
    
    if (!buf)
    {
        printf("Error: HeapAlloc = %d\n", GetLastError());
        return;
    }
    
    if (!ReadFile(hFile, buf, size, &dw, NULL))
    {
        printf("Error: ReadFile = %d\n", GetLastError());
        return;
    }
    
    DWORD t2 = GetTickCount();

    printf("vector size = %d, loading time = %d ms.\n", size, t2 - t1);
    
    HeapFree(GetProcessHeap(),0, buf);
    CloseHandle(hFile);
}

S:\!IVAN\cpp>2.exe
--------------------------------------------------
S:\cpp>file2vect2.exe
vector size = 13107200, loading time  = 94 ms.

S:\cpp>FileToBuf.exe
vector size = 14308877, loading time = 31 ms.
--------------------------------------------------
S:\cpp>file2vect2.exe
vector size = 734255104, loading time  = 16469 ms.

S:\cpp>FileToBuf.exe
vector size = 734410752, loading time = 11282 ms.
--------------------------------------------------
S:\cpp>file2vect2.exe
vector size = 734332928, loading time  = 18297 ms.

S:\cpp>FileToBuf.exe
vector size = 733882368, loading time = 11453 ms.

boost::filesystem::file_size( boost::filesystem::path( filename ) );

АШ>    std::ifstream::pos_type size = 0;

АШ>    .
АШ>    .
АШ>    .

АШ>       f.read(&buffer[0], size);

       f.read(&buffer[0], static_cast<streamsize>(size));

24.5.1/1 istream_iterator reads (using operator>>) successive elements from the input stream for which
it was constructed. After it is constructed, and every time ++ is used, the iterator reads and stores a value of
T. If the end of stream is reached ( operator void*() on the stream returns false), the iterator
becomes equal to the end-of-stream iterator value. The constructor with no arguments
istream_iterator() always constructs an end of stream input iterator object, which is the only legitimate
iterator to be used for the end condition. The result of operator* on an end of stream is not
defined. For any other iterator value a const T& is returned. The result of operator-> on an end of
stream is not defined. For any other iterator value a const T* is returned. It is impossible to store things
into istream iterators. The main peculiarity of the istream iterators is the fact that ++ operators are not
equality preserving, that is, i == j does not guarantee at all that ++i == ++j. Every time ++ is used a
new value is read.