Question: Is there a simple way to convert a string of numbers separated by spaces into a vector of ints or something that I can easily convert into a vector? 

I am creating an input operator (>>) to make a binary tree using values input from command line. And this is the main that goes with it

```
int main(int argc, char **argv)
{
stringstream stream;
stream << " 10" << " 11" << " 10" << " 2" << endl;
tree = new binary_tree();
stream >> *tree;
if (tree->inorder() != string("7 10 11")) //inorder() prints the tree in order
cout << "Test passed" << endl;
delete tree;

return 0;
}

```

The problem I am having is that while I can create and print the values that I need, I can't convert them and put them into a vector - for which I have a working defined method that creates a tree from the values.

```
std::istream& operator>>(std::istream &in, binary_tree &value)
{
vector<int> input_tree;
string readline;     
getline(in, readline);
cout << "(" << readline << ")" << endl; //prints correctly - (10 11 10 2)

    //where I need to insert insert values into vector

for(int i = 0; i < input_tree.size(); i++)
{
    insert(input_tree[i], value);    //inserts the values from a vector into a binary tree
}

return in;  
} 

```

I have tried looping through the string and using stoi() on each character but it always errored whenever the spaces were causing errors.

Thanks for any help and sorry if I've missed any important information out.

Answer: 
> 
> Thats what Im wanting to do, just take the last 4 bits of y and put it with all of x. Making a 12 bit result 
> 
> 
> 

```
x = 01234567
y = 23458901
doBitWise = 890101234567

```

In that case, you should left shift the **y** by 8, and mask the front 4 bits:

```
uint16_t result = (((unsigned short)y << 8) & 0xF00) | x; //result will be casted to uint16_t

```

Note: be careful of the operator precedence. + comes before <<, thus parentheses is needed

Note 2: to prevent undefined behavior when int is 16-bit and to ensure that the result of y << 8 will be having at least 16-bit, explicit casting to unsigned short is added (since y is originally unsigned char). Besides, the inserting of x is using bitwise OR operator |.
As others have said the problem here is that before doing arithmetic, narrow integer types are converted to `int`, a signed type. But the solution to that should be much simpler, just force unsigned arithmetic:

```
uint16_t result = (x & (1U << 4) - 1U) | (y);

```

Here, the literals are `unsigned`, so is then the result of the `<<`, `&`, `-` and then `|` operators. This is because these operators, if presented with `int` and `unsigned` always do a conversion of the `int` part to `unsigned`.

For the final conversion from `unsigned` to `uint16_t`, this always well defined by modulo arithmetic and no sane compiler should complain about this.