For loop acting on vector of integers is behaving strangely - c++

Question

#include <iostream>
#include <vector>
std::vector<int> normalize(std::vector<int> a) {
for (int j = a.size() - 1; j > 0; --j) {
while (a[j] > 9) {
a[j] = a[j] - 10;
std::cout << '!'; //Just to test if the loop is executed (the correct # of times)
++a[j - 1];
}
}
// checks that the last digit isnt too large, makes new digit otherwise
if (a[0] > 9) {
a.insert(a.begin(), 0);
while (a[1] > 9) {
a[1] -= 10;
++a[0];
}
}
return a;
}
// for debugging convenience
void printVector(std::vector<int> a) {
for (int i = 0; i < a.size(); ++i) {
std::cout << a[i] << ' ';
}
std::cout << std::endl;
}
int main()
{
std::vector<int> a;
a.push_back(1); a.push_back(2); a.push_back(33);
normalize(a);
printVector(a);
return 0;
}
This program represents large integers as lists of digits, The normalize function would change {1,2,33} to {1,5,3}, representing 153, for instance. I'm new to C++ so I'm not using classes and I'm not using any big integer headers that would have this all much better implemented.
Returns: !!!1 2 33
as though the vector has not been changed. But then how would the "std::cout '!'" line print the correct number of times, or even the while loop terminate at all?

Answer 1

In your function
std::vector<int> normalize(std::vector<int> a)
you are passing a by value, so it won't be modified once the function exits. To make it work, you should use your current implementation as
auto result = normalize(a); // now we get the result
printVector(result); // and display it
To avoid making an un-necessary copy, you should pass the agument by const reference:
std::vector<int> normalize(std::vector<int> const& a)
If you want to modify the parameter that's passed to your function, you should pass by reference:
std::vector<int> normalize(std::vector<int>& a) // now we can modify a
However, it's a good idea to implement functions as black boxes without side effects (if possible), as it will make testing and multi-threading much easier, so I'd suggest passing by const reference then returning the result.

Answer 2

Your function uses pass-by-value. This means that the call normalize(a); does not modify a, it modifies a copy of a.
To fix this there are two ways:
Make the call a = normalize(a);
Make the function have void return type, and use pass-by-reference (put a & in the function prototype before the parameter name).
The first way is more natural but unfortunately has performance problems for large vectors, so most people would prefer the second way
NB. You currently don't handle the possibility of a[0] > 9 after the insert and adjustment; and it would be simpler to store the least-significant digit first, then you can append instead of inserting at the front, and you wouldn't need to divide your algorithm up into the two parts.