I am trying to store multiple integers in one int variable. So like this:
int num1 = 2;
int num2 = 6;
int num3 = num1 + num2;
But I get 8. I want 26. I am aware this is the result I should expect, but I would just like a method of tying the integers together instead of adding them and I couldn't think of a better example.
Thank you!
You can convert them to string, add them, and convert them back (which isn't efficient as the second option)
int num3 = std::stoi(std::to_string(num1) + std::to_string(num2));
or a more "mathy" way (which only works if num2 is only a digit)
int num3 = num1 * 10 + num2;
Note that the first solution works for any numbers, which also means that without storing the length of the number there is no way to get the original numbers back.
Well, what about just adding the digits multiplied and pushed to their intended positions?
int num3 = num1 * 10 + num2;
I think you want to concatenate the two string literals.
Convert the int to string and then concatenate the two strings
This will give you the concatenated string "26" from the strings "2" and "6"
If you need the int 26 then you can convert it back to an int after the concatenation.
Good luck :-)
You can store multiple integers as one integers using bitwise operation.
For the example you provided:
int num1 = 2; // 0010
int num2 = 6; // 0110
You can then concatenate the numbers using 4 bits:
int num3 = (2 << 4) | 6; // 00100110 num3 = 38
Or if you are using 3 bits, then it becomes:
int num3 = (2 << 3) | 6; //010110 num3 = 22
To retrieve back the numbers, you will have to do a Right shift on num3 to get num1 and do a bitwise AND with 2 to the power of number of bits - 1 (2 ^ n - 1, where n = number of bits).
For 4 bits, num3 = 38;
num1 = num3 >> 4; // 2
num2 = num3 & (2 * 2 * 2 * 2 - 1); // 6
For 3 bits, num3 = 22:
num1 = num3 >> 3; // 2
num2 = num3 & (2 * 2 * 2 * 2 - 1); // 6
Hope this helps.
Little bit late, but:
You could do make a string of those two integers and then convert it back to a string.
Here's my more simple but bigger code:
int foo = 2;
int bar = 6;
string temp = to_string(foo) + to_string(bar);
int foobar = stoi(temp);
cout << foobar;
And here's my smaller one:
int foo = 6;
int bar = 2;
int foobar = stoi(string(to_string(foo)) + string(to_string(bar)));
cout << foobar;
Maybe not as efficient as the other examples but it also works if there are two-digit numbers.
This seems like an old question and I've stumbled that I want to have this capability also.
Because nobody yet mentioned this, if you would have threshold that would validate that the number is below that range ceiling what you can do is store both numbers in one number type by storing their bits separately.
You would store the first number setting the bits as you would in little endian, for the second number you would store the bits in big endian.
Then you can abstract this to working just with bytes as size and the length of a byte depending on your arch, usually 1 byte is 8 bits so that means using lets say uint16 (2 bytes) we can restrict each number to half the space as in each number stored would need to be a uint8.
If we store in a uint8 then both numbers should be represented within 4 bits each.
This would be useful for small numbers because of the obvious restrction..
// Examples
// uint8 - store first number - little endian
[0][0][0][0] [1][1][1][1] = 15 // storing in 4 bits the max value
// uint8 adding value of 3 as second value in big endian
[1][1][0][0] [1][1][1][1]
// uint16 store first number - little endian
[0][0][0][0][0][0][0][0] [1][1][1][1][1][1][1][1] = 255 // storing in 8 bits the max value
so max value is 15 if you store in 4 bits and 255 if you would store in 8 bits, anything stored above that would overflow and corrupt the other stored value.
Obviously treating them as little endian and big endian only works with two numbers when you don't need further partitioning as it helps when thinking about how they are stored. And there might be libraries that automatically help between endianness representation.
But you could partition the bytes in how many slices of bits you want it's just that without using endianness you might need to do more conversion manually.
Partitioning is also in the answer of intotito yet few answers point out that you need a ceiling threshold for your values, else it's just a loaded footgun.
You would have to store them as strings to concatenate them like that as so:
string str_num1 = to_string(num1);
string str_num2 = to_string(num2);
string result = num1 + num2;
This is a bad way to do it though because if you use any number that's not 1 digit, it will get way too complicated to store and/or pull out the data.
Use a vector or pair. Much easier and less hassle:
pair<int, int> presult = make_pair(num1, num2); ///or
vector<int> vresult;
vresult.push_back(num1);
vresult.push_back(num2); ///num1 in spot 0, num2 in spot 1
vector should be best since it can hold arbitrarily large number of ints
