Q:

add 1 to number represented by array of digits

The question goes as follows:
Given a non-negative number represented as an array of digits,
add 1 to the number ( increment the number represented by the digits ).
The digits are stored such that the most significant digit is at the head of the list.   
Solution:
 class Solution {
        public:
            vector<int> plusOne(vector<int> &digits) {
                reverse(digits.begin(), digits.end());
                vector<int> ans;
                int carry = 1;
                for (int i = 0; i < digits.size(); i++) {
                    int sum = digits[i] + carry;
                    ans.push_back(sum%10);
                    carry = sum / 10;
                }
                while (carry) {
                    ans.push_back(carry%10);
                    carry /= 10;
                }
                while (ans[ans.size() - 1] == 0 && ans.size() > 1) {
                    ans.pop_back();
                }
                reverse(ans.begin(), ans.end());
                reverse(digits.begin(), digits.end());
                return ans;
            }
    };

This is the solution i encountered while solving on a portal..
I cannot understand this :
 while (ans[ans.size() - 1] == 0 && ans.size() > 1) {
                ans.pop_back();
            }

why do we need this while loop ? I tried self evaluating the code for example 9999 and i couldn't understand the logic behind popping the integers from the end! 
Please help.

A:

The logic
while (ans[ans.size() - 1] == 0 && ans.size() > 1) {
    ans.pop_back();
}

removes any 0's at the end after incrementing the value by 1.
The logic is vague and isn't needed since you would never need ever find xyz..0000 in the answer set. 
Example that the logic builder might have though: 9999 would be changed to 0000100 therefore he removes 0's to convert the conversion to 00001, which is reversed to form 10000, but since this scenario will never occur, the code should be removed from the logic. 

