Best Way to Reduce Overloading when Casting is Sufficient in C++

Question

The avr-gcc compiler offers the F() macro as a good way to define strings in my statements and then place the strings in program memory. The strings end up being of type __FlashStringHelper, however, and I will get an error if I try to pass them to functions that expect "const char *".

I can cast each one and the code will function. For example this code will work:

int16_t LT_printf(const char *format, ...);
LT_printf((const char *)F("TESTING!\r\n"));

I can also define an overload function that does nothing but receive the __FlashStringHelper and then turn it into a (const char *). This also works:

int16_t LT_printf(const __FlashStringHelper *format, ...);
LT_printf(F("TESTING!\r\n"));

The second solution executes less efficiently than the first, but at least I don't have hundreds of casts in my code any more.

Is there a way to eliminate the casts inside every function call, but still not need the overload function?

Edited to Add More Examples that build (not that any of the examples are something I'd really do...I'm just interested in the pointer to const __FlashStringHelper):

typedef struct
{
  char test_string[20];
} TEST_STRUCT_TYPE;
const TEST_STRUCT_TYPE PROGMEM test_struct = {"STRUCT TESTING!\r\n"};
const uint8_t PROGMEM test_array[] = {'A', 'R', 'R', 'A', 'Y', ' ', 'T', 'E', 'S', 'T', 'I', 'N', 'G', '!', '\r', '\n', NULL};
const char PROGMEM test_string[] = {"TEST TESTING!\r\n"};

void test()
{
  LT_printf(test_string);                       // doesn't need a cast

  LT_printf((const char *)F("F TESTING!\r\n")); // these need a cast
  LT_printf((const char *)&test_struct);
  LT_printf((const char *)test_array);

  LT_printf((PGM_P)F("F TESTING!\r\n"));        // this is the cleaner cast
  LT_printf((PGM_P)&test_struct);
  LT_printf((PGM_P)test_array);
}

This results in this output:

TEST TESTING!
F TESTING!
STRUCT TESTING!
ARRAY TESTING!
F TESTING!
STRUCT TESTING!
ARRAY TESTING!

Answer 1

  LT_printf(test_string);                       // doesn't need a cast
  LT_printf((const char *)F("F TESTING!\r\n")); // these need a cast
  LT_printf((const char *)&test_struct);

You can't just cast away a different data type and expect it to work. Presuming that test_string works then it expects to print from RAM and not PROGMEM which is in a separate address space.

The simple solution in your case is to derive the class that LT_printf is in (whatever that is) from Print and then print, println etc. will just work.

For example, I have a library that prints to an I2C LCD. I derive it from Print like this:

class I2C_graphical_LCD_display : public Print

Now all your class has to do is implement write in your class (ie. writing a single byte) and the Print class takes care of the rest: both writing from RAM and PROGMEM via the F() macro.

My answer doesn't address how to get printf to work, although you could look at this.

You might be better off looking at the Streaming library which lets you stream output in a C++ style, rather than using printf-style outputting.

---

Here is a simple way of implementing printf (however from RAM only) by adding a couple of helper functions:

int getChar (FILE *fp)
  {
  while (!(Serial.available()));
  return (Serial.read());
  }  // end of getChar

int putChar (char c, FILE *fp)
  {
  Serial.write (c);
  return c;
  }  // end of putChar

void setup ()
  {
  Serial.begin(115200);
  fdevopen (putChar, getChar);
  }  // end of setup

void loop ()
  {
  int temp = 30;

  printf ("The temperature is %d degrees C.\n", temp);
  delay (100);
  }  // end of loop

fdevopen tells the Standard IO library how to get and put characters. In this particular case I am using Serial, but it could be Serial1 or SoftwareSerial, etc.

---

If you want to use PROGMEM constants (ie. F()) then I think the easiest is to use the Streaming library. eg.

#include <Streaming.h>

void setup ()
  {
  Serial.begin (115200);
  }  // end of setup

void loop ()
  {
  int temp = 30;    
  Serial << F("The temperature is ") << temp << F(" degrees C") << endl;
  delay (100);
  }  // end of loop

That is even more compact, and saves RAM by using the F() macro. It's pretty readable too.