CODEWITHSUNDEEP
c++arduino
Mvz
Mvz

Reputation: 507

Right way of defining a buffer when using sprintf

In my Arduino sketch I use sprintf to format a reply. The formatted data will be send using SPI.

I have to set the buffer length, but I don't know how large would be good. Here is a piece of the code:

  uint8_t myValue = 4;

  // Set buffer
  unsigned char data[1000];
  // Reset this buffer
  memset(data, 0, sizeof(data));

  // Format the reply
  sprintf((char *)data, "This is the int value: %d", \
      myValue);

I can also set the buffer to 0 (unsigned char data[0];), The code compiles and the reply is the same as using a large buffer. I can't explain this?

It seems malloc() and free() are pretty rare in the Arduino world...

What is the right way of using a buffer in Arduino?

Upvotes: 0

Views: 2030

Answers (2)

Peter
Peter

Reputation: 36607

I can also set the buffer to 0 (unsigned char data[0];),

If this is true, you're just getting lucky (or unlucky, depending on how you look at it). The behaviour of your code doing this is undefined, in both C and C++. Which, among other things, means it is not guaranteed to work (e.g. it might break if your compiler is ever updated).

As to better options .... Your question is tagged C++ and C, and different approaches are preferable in different languages.

Assuming you are using C, and your implementation complies with the 1999 standard or later, you can use snprintf().

  char *buffer;
  int length = snprintf((char *)NULL, 0, "This is the int value: %d",  myValue);
  buffer = malloc(length + 1);    /*   +1 allows for terminator */
  snprintf(buffer, length, "This is the int value: %d", myValue);

   /*  use buffer  */
  free(buffer);

The first call of sprintf() is used to recover the buffer length. The second to actually write to the allocated buffer. Remember to release the dynamically allocated buffer when done. (The above also does not check for errors - snprintf() returns a negative value if an error occurs).

If your C library does not include snprintf() then (AFAIK) there is no standard way to work out the length automatically - you will need to estimate an upper bound on length by hand (e.g. work out the length of output of the largest negative or positive int, and add that to the length of other content in your format string).

In C++, use a string stream

 #include <sstream>
 #include <string>

 std::ostringstream oss;
 oss << "This is the int value: " << myValue);
 std::string str = oss.str();

 const char *buffer = str.data();

 //   readonly access to buffer here

 //   the objects above will be cleaned up when they pass out of scope.

If you insist on using the C approach in C++, the approach above using snprintf() can be used in C++ if your implementation complies with the 2011 standard (or later). However, in general terms, I would NOT recommend this.

Upvotes: 0

ewramner
ewramner

Reputation: 6233

I would recommend using snprintf instead, where you specify how large the buffer is. With the current approach sprintf assumes that the buffer is large enough, so if you pass it a small buffer it will stomp over some other memory. Not good (and may explain the weird results you sometimes get)!

You can use a fixed buffer as in your current code. Allocating also works, but it has more overhead.

Upvotes: 1

Related Questions