Wsrtjtyk

I have a problem i need to pass streamsize value to vector. if i'm not pass it to fixed size. it will overhead with emplace_back with thousand element. the error compiler is possible cause lost data.

ifstream input(i_inputFilePath, ios::binary);

if (input.is_open())

{

    ofstream output(o_outputFilePath, ios::binary);

    std::array<char, 1024> buffer;

    while (true) {

        input.read(buffer.data(), buffer.size());

        streamsize dataSize = input.gcount();

        if (dataSize) 

        {

            std::vector<char> data(dataSize); // here the problem

            for (DWORD i = 0; i < dataSize; i++)

            {

                data.emplace_back(buffer[i]);

            }

            std::rotate(data.begin(), data.begin() + 1, data.end());

            output.write(data.data(), dataSize);    

        }

        else 

        { 

            output.close();

            input.close();

            break;

        }   

    }

}

else

{

    cout << "File is not exist";

}

If you pass a single integer argument to the constructor of std::vector (as in std::vector<char> data(dataSize);) is will default-construct that many elements in it and its size will be the integer passed.

If you then emplace_back into it, it will increase its size, not overwrite the already constructed elements.

If you want to emplace_back all your elements, simply do so, no need to pass the final size to the constructor:

std::vector<char> data;

Most implementations of std::vector will not reallocate on each emplace_back, but will e.g. double the allocated space each time it runs out of space. Therefore this will not really be that bad on average.

If you are concerned about reallocations, then you can force the vector to pre-allocate space with

data.reserve(dataSize);

This will not actually construct any elements but make sure the necessary space is allocated in advance.

If you are getting an error message about the conversion from std::streamsize to std::size_t, then this is a false-positive, because in this particular case you know that dataSize can only have values ranging from 0 to 1024. The compiler is correct in warning that dataSize's type is signed and could therefore be holding a negative value that can not be represented by std::size_t, which is unsigned.

You can test whether this assumption is correct with something like

streamsize dataSize = input.gcount();

if(dataSize < 0 || dataSize > buffer.size()) {

    throw std::range_error("dataSize has unexpected value!");

}

data.reserve(static_cast<std::size_t>(dataSize));    

This makes sure that dataSize is not accidentally negative or larger than expected (if it is, it will throw an exception) and otherwise it will hint at the compiler that you really want to do the narrowing conversion with the explicit cast, which should suppress the warning/error message.