#include <iostream>

int main()
{
	int* a = new int[ 2 ];
	a[ 0 ] = 1;
	a[ 1 ] = 2;

	delete[] a;

	std::cout << a[ 1 ] << std::endl;

	return 0;
}

#include <iostream>

int main()
{
	int* a = new int[ 2 ];
	a[ 0 ] = 1;
	a[ 1 ] = 2;

	std::cout << a[ 1 ] << std::endl;

	delete[] a;

	return 0;
}

#include <iostream>

int main()
{
int* a = new int[ 1000000 ];
a[ 0 ] = 1;
a[ 999999 ] = 6;

delete[] a;
std::cout << a[ 999999 ] << std::endl;

return 0;
}

class SomeData {
    double d;
    string s;
};

SomeData sd;
inf.write( reinterpret_cast< char* >( &sd ), sizeof( SomeData ) );

#include <iostream>
#include <limits>
#include <string>
#include <vector>
#include <fstream>
#include <algorithm>
#include <memory>
#include <map>

using namespace std;

static const char* file_name = "t.bin";
const string user_messages   = "Show records from file";

const int BYTE_OF_INT        = sizeof( int );
const int BYTE_OF_DOUBLE     = sizeof( double );
const int BYTE_OF_FLOAT      = sizeof( float );
const int BYTE_OF_CHAR       = sizeof( char );
const unsigned BIT_PER_BYTE  = 8;



struct Record {
    int    x;
    string str;
public :
    Record( int x = 0, const string& str = "" )
        :x( x ), str( str )
    {   }

    void show( ostream& o ) const {
        o << endl << x << " " << str;
    }
};

inline
ostream& operator <<( ostream& ouf, const Record& rec ) {
    for( int cursor = 0, i = rec.x; cursor < BYTE_OF_INT; ++cursor, i >>= BIT_PER_BYTE )
        ouf.put( i & 0xFF );

    ouf << rec.str << '\0';
    return ouf;
}

inline
istream& operator >>( istream& inf, Record& rec ) {
    rec.x = 0;
    for( int i = 0; i < BYTE_OF_INT; ++i )
        rec.x += ( inf.get() << ( BIT_PER_BYTE * i ) );

    getline( inf, rec.str, '\0' );
    return inf;
}

class ClientDatabase {
private :
    vector< int > block_of_bytes;
    fstream clf;

public :
    void write_some_records( const vector< const Record* >& con );
    void show_records();
    void show_records_at( int pos );
    void edit_record_at( int pos, const Record& rec );
    void append_new_record( const Record& rec );
};


void ClientDatabase::write_some_records( const vector< const Record* >& con )  {
    clf.open( file_name, ios::binary | ios::out | ios::trunc );
    for( vector< const Record* >::const_iterator b = con.begin(), e = con.end(); b != e; ++b ) {
        block_of_bytes.push_back( clf.tellp() );
        clf << *( *b );
    }
    clf.close();
}



void ClientDatabase::show_records() {
    clf.open( file_name, ios::binary | ios::in );
    auto_ptr< Record > rec( new Record() );
    cout << endl << endl << user_messages;
    while( clf >> *rec ) {
        block_of_bytes.push_back( clf.tellg() );
        rec->show( cout );
    }
    clf.close();
}

void ClientDatabase::show_records_at( int pos )
{
    Record temp;
    clf.open( file_name, ios::binary | ios::in );
    clf.seekg( ios::beg );
    clf.seekg( block_of_bytes.at( pos ), ios::beg );
    clf >> temp;
    temp.show( cout );
}



void ClientDatabase::append_new_record( const Record& rec ) {
    clf.open( file_name, ios::binary | ios::out | ios::app );
    clf << rec;
    clf.close();
}

struct DeleteObject {
    template< typename T >
    void operator()( const T* ptr ) const {
        delete ptr;
    }
};


int main()
{
    ClientDatabase cl;
    vector< const Record* > records;
    records.push_back( new Record( 1, "Windows"   ) );
    records.push_back( new Record( 2, "Linux"     ) );
    records.push_back( new Record( 3, "Macintosh" ) );
    records.push_back( new Record( 4, "This is a long long long long a long record ever !!!!" ) );

    cl.write_some_records( records );

    Record new_rec( 5, "VVVVVVVVVVVV" );
    cl.append_new_record( new_rec );

    for_each( records.begin(), records.end(), DeleteObject() );

    cl.show_records();

    return 0;
}