C / C++ / MFC

Your::Your ()
: My (42)
{
}

Your::Your ()
: My [0](42), My [1](420), My [2](3)
{
}

My my[] = {3,5,11}; // correct: this will invoke My::My(int) for each member
My my3[3] = {3,5,11}; // correct: predetermined array size sorresponds to size of initializer list
My my4[4] = {3,5,11}; // error: elements of partially initialized array must have default constructor

class My {
   int val;
public:
   My(int i) : val(i) {}
   int get() const {return val;}
};
class Your {
   char myPlaceHolder[3][sizeof(My)];
   My* my;
public:
   Your()
   { 
      my = (My*)(myPlaceHolder); // just to assign the address
      new (&my[0]) My(3);         // calls My::My(int) in-place using the memory allocated at myPlaceHolder[0]
      new (&my[1]) My(5);
      new (&my[2]) My(11);
   }
   int operator[](int i) const { return my[i].get(); }
};
void testYour() {
   Your your;
   std::cout << "my[0]="<<your[0] << " ; my[1]="<<your[1] << " ; my[2]=" <<your[2] << std::endl;
}

msn92 wrote:

Since it (firefox) is opensource, is not it possible to use it in the mfc application?

goldenrose9 wrote:

as it is not initialized using new/malloc, so i cannot use delete[]/free.

Yusuf wrote:

delete reader

delete reader

delete []reader

delete [] reader;

std::vector<char> read_from_file( std::size_t bytes_to_read )
{
    std::vector<char> bytes_read( bytes_to_read );
    std::size_t number_bytes_read = 0;
    ReadFile( handle_of_file, &bytes_read[ 0 ], &number_of_bytes_read, 0 );
    return bytes_read;
}

std::vector<char>& read_from_file( std::size_t bytes_to_read, std::vector<char> &bytes_read )
{
    bytes_read.reserve( bytes_to_read );
    std::size_t number_bytes_read = 0;
    ReadFile( handle_of_file, &bytes_read[ 0 ], &number_of_bytes_read, 0 );
    bytes_read.resize(number_of_bytes_read);
    return bytes_read;
}

Niklas Lindquist wrote:

bytes_read.reserve( bytes_to_read );

goldenrose9 wrote:

3rd parameter is missing in the ReadFile()

goldenrose9 wrote:

Can i use BYTE instead of char to read the file

std::vector<BYTE> bytes_read;

std::vector<std::string> bytes_read;

A some_function()
{
    A a;

    /* Other stuff */

    return a;
}

void some_function( memory_block_the_size_of_a &a )
{
    new( &a ) A;

    /* Other stuff */
}

A a = some_function();

memory_block_the_size_of_a block;
A &a( *reinterpret_cast<A *>( block ) );
some_function( &block );

/* Other stuff */

a->~A();

A a = some_function( b );

const size_t wanted_chunk_size = 512;
std::vector<char> buffer;
do
{
    read_from_file(wanted_chunk_size, buffer);
    write_to_somewhere(buffer);
}
while (buffer.size() == wanted_chunk_size);

Aescleal wrote:

you can actually end up with slower code if someone writes (naively):

A a = some_function( b );

as you still end up triggering the copy constructor.

Aescleal wrote:

- It's assignment not copy construction (so A a = some_function() can invoke NRVO while a = some_function() won't).