String Functions

The 825 can be programmed using C/C++ character array strings and standard C library string functions such as:

char szMsg[10];
char szID[10];
strcpy(szID, "123");
sprintf(szMsg, "ID: %s", szID);
PrintLCD(szMsg);

This is the traditional C programming way of handling strings. The C language has no true string type; strings are just arrays of characters. This is very fast and efficient because the compiler generates code to read and write the memory locations directly. However, there is no automatic checking that pointers point to valid memory, or to prevent writing beyond memory that is allocated. It is very easy to crash an 825 indicator by programming this code incorrectly.

In the above example the szMsg and szID character arrays are each allocated 10 bytes. C strings require a null character at the end to tell various functions such as strcpy when to stop reading characters. This means szMsg and szID can contain a maximum of 9 characters each. If the strcpy(szID, "123") is changed to strcpy(szID, "1234567890") the compiler will generate code that writes the null character into an invalid memory location. When the program is executed this may crash the indicator immediately when this code executes, it may not cause a crash until some other time in execution when that memory location becomes important, or it may cause some other strange behavior in the program. If the strcpy is changed to strcpy(szID, "123456") szID will not overflow, but szMsg will overflow in the sprintf statement that follows.

snprintf is a safer alternative to sprintf. snprintf has an additional parameter. The second parameter specifies the size of the buffer. The snprintf function will not exceed the specified buffer size.

char szMsg[10];
char szID[10];
strcpy(szID, "123");
snprintf(szMsg, sizeof(szMsg), "ID: %s", szID);
PrintLCD(szMsg);

The 825 library also provides sprintf_s which is a macro to perform snprintf and automatically provide the second parameter using the sizeof the buffer provided in the first parameter. This can only be used when the first parameter is a simple character array as in the above example. If the first parameter is a pointer to an array this cannot be used because the sizeof operator will not give the desired result.

There is also a strncpy function that limits string copy to a specified length. However, strncpy is not recommended as a safe strcpy because it does not automatically NULL terminate strings.

825 applications may also be compiled using the newer C++ string type: std::string. Using std::string does not require as much diligence from the programmer. The string will automatically allocate more memory and grow if needed by an assignment. The operations are also more like the BASIC language so this is helpful for programmers who are not as skilled in C/C++.

string strMsg;
string strID;
strID = "123";
strMsg = "ID: ";
strMsg = strMsg + strID;
PrintLCD(strMsg);

The 825 standard library functions now accept string parameters. We are recommending using strings in application programs where possible to reduce the possibility of pointers to invalid memory, or overflow bugs. The exception is when speed is important and frequent allocation of memory may be detrimental. For example, for a scoreboard output or computer output that will happen several times per second it may be best to use old style C character arrays.

For more information about std::strings refer to: ​http://www.cplusplus.com/reference/string/string/

To further help with string operations some additional functions are now provided in the 825 library.

1. FloatToStr
2. IntToStr
3. StrFmt
4. StrFmtLen
5. StrToFloat
6. StrToInt
7. StrTrimLeft
8. StrTrimRight