Infinity value and buffer - c++

Question

i have a score board that get update all time with new information and the buffer size is = amount of rows my
score board can handel, but i'm trying to make it infinity without limits.
what i'm trying to do is as-sign infinity value to a buffer like that:
const int infinity = std::numeric_limits<const int>::infinity();
char Buffer_format_text [infinity];
but it dont work, becouse it says:
error C2057: expected constant expression
error C2466: cannot allocate an array of constant size 0
is there a way to do that? or trick? , please help me. Don't ask me why i want to do that, i'm asking how to do that.
Update:
This how i'm doing it with sprintf , how do you that in ostringstream ?
char Buff[100];
int length = 0;
int amount_of_space = 8;
length += sprintf(Buff+length,"%-*s %s\n", amount_of_space, "Test", "Hello");
this output: Test Hello

Answer 1

In C++11, infinity() is constexpr, so in theory you could use it directly this way:
char Buffer_format_text[std::numeric_limits<const int>::infinity()];
However, the problem here is that int cannot represent infinity. If you tried this:
std::cout << std::numeric_limits<const int>::has_infinity;
You would see that 0 (false) is printed to the standard output (live example). The infinity() function for specializations of std::numeric_limits where has_infinity is false will return 0 - in fact, the function is meaningless in those cases - and you cannot create arrays of size 0.
Besides, you cannot expect an array of infinite size to be allocated - how would it fit into memory? The right approach, if you do not know in advance the size of your vector, is to use std::vector or a similar container that does allocate memory upon request.
UPDATE:
It seems what you actually need an infinite array for is to be able to build up a string whose size is not known in advance. To encapsulate such a string that grows dynamically, you can use std::string.
In order to perform type-safe output into an std::string and replace sprintf(), you could use std::ostringstream. That would allow you to insert stuff into a string the same way you would print it to the standard output.
Then, once you are done working with the std::ostringstream, you can get an std::string object from it by calling the str() member function.
This is how you could use it in a simple example:
#include <string>
#include <sstream>
#include <iostream>
#include <iomanip>
int main()
{
std::ostringstream oss;
oss << "The answer is: ";
oss << 42;
oss << ", and this is a double: ";
oss << 3.14;
oss << ". " << std::endl;
oss << "Oh, btw, you can also output booleans: ";
oss << std::boolalpha << true;
oss << ". See? It's easy!" << std::endl;
std::cout << oss.str();
}
Live demo.

Answer 2

It doesn't make sense to declare a buffer as big as infinity, both because integral types cannot (normally) represent infinity (the infinity member of numeric_limits is there for FP types), and because no machine could create a buffer infinity bytes big. :)
Instead, use a container that can handle the reallocations needed for new insertions by itself, limited only by the available memory, e.g. std::vector (or std::deque or others, depending from your insertion/removal patterns).
Edit: since the question seem to be about creating an arbitrarily long string, the "C++ answer" is to use std::ostringstream, which allow you to write as many elements as you like (limited only by the available memory) and provides you a std::string as a result.
std::ostringstream os;
for(int i=0; i<1000; i++)
os<<rand()<<" ";
std::string out=os.str();
// now in out you have a concatenation of 1000 random numbers
Edit/2:
This how i'm doing it with sprintf , how do you that in ostringstream ?
char Buff[100];
int length = 0;
int amount_of_space = 8;
length += sprintf(Buff+length,"%-*s %s\n", amount_of_space, "Test", "Hello");
// needed headers: <sstream> and <iomanip>
std::ostringstream os;
int amount_of_space = 8;
os<<std::left<<std::setw(amount_of_space)<<"Test"<<" "<<"Hello";
std::string out=os.str(); // you can get `length` with `out.size()`.
But if you need to do multiple insertions call os.str() only at the end, when you actually need the string. Again, no need to keep track of length, the stream does it automatically.

Answer 3

You basically cannot allocate an array with really infinite memory, either on stack or on the heap.
You also cannot allocate array with size 0 since it is illegal according to the standard.
You may try to use std::vector which grows when necessary by itself. but you still cannot have infinite memory to allocate since your disk space is limited no matter how large it is.

Answer 4

You should use a container which can grow dynamically, such as std::vector (or, as your case seems to be text, std::string).
You can use std::ostringstream to construct a std::string like this:
#include <iomanip>
#include <sstream>
std::ostringstream ss;
ss << std::setw(amount_of_space) << std::left << "Test" << ' ' << "Hello" << '\n';
std::string result = ss.str();