Better size aligning? I have the following two vectors in C++11:

vector&lt;unsigned char&gt; left = { 1, 2, 3, 4, 5, 6 }; // it is meant to represent the number: 123456
vector&lt;unsigned char&gt; right = { 1, 2, 3, 4 }; // meant to be number: 1234


After a function processes them, they become:

left = { 6, 5, 4, 3, 2, 1 };
right = { 4, 3, 2, 1 };


Now, I need to complete the shorter one with zeros at the end until they are equal in size(). I have thefollowing method:

void bigint::process_operands( vector&lt;unsigned char&gt; &amp; left, vector&lt;unsigned char&gt; &amp; right )
{
    size_t left_size = left.size();
    size_t right_size = right.size();

    if( left_size &lt; right_size )
    {
        size_t size_diff = right_size - left_size;

        for( size_t i = 0; i != size_diff; ++i )
            left.push_back( '0' );
    } else if( right_size &lt; left_size )
    {
        size_t size_diff = left_size - right_size;

        for( size_t i = 0; i != size_diff; ++i )
            right.push_back( '0' );
    }
}


Is there any better implementation?
Firstly, given that you're using vector without namespace qualification (that is, not as std::vector), I assume you have a using namespace std; in this code. This is generally a bad idea, but especially so in this case. You use vector&lt;unsigned char&gt; &amp; right (and vector&lt;unsigned char&gt; left), however, there is a std::right (and a std::left) defined in &lt;ios&gt;. This could potentially lead to some very confusing compiler errors. 

Using a few tricks from &lt;algorithm&gt;, we can shorten the above code considerably.

void bigint::process_operands(vector&lt;unsigned char&gt; &amp; left_, vector&lt;unsigned char&gt; &amp; right_)
{
   auto&amp; shorter = (left_.size() &lt; right_.size()) ? left_ : right_;
   std::fill_n(std::back_inserter(shorter), std::abs(left_.size() - right_.size()), '0');
}


This is much more terse, but I find that using the standard library actually makes this code easier to read and more clear as to exactly what it is doing.