Sorry to ask something so simple, but I wonder if someone can point me in the right direction. I just want to create and read from, and edit, text strings (no need for PROGMEM). Just simple text strings.
char *Alpha[] = { "A", "B", "C", };
So far so good. I can even read from it okay:
if (Alpha[0]=="A") // Dot Dash { sound.tone(NOTE_C5,100, NOTE_REST, 100, NOTE_C5,400); }
Is there a way to insert letters like into the string like: Alpha[0] = "A"; ?
Thanks!
Use single quotes for single ASCII characters:
Alpha[0] = 'A';
Double quotes create null terminated ASCII strings.
Oh nice, Iāll do that thanks!
Also when using the single quotes for single characters you donāt need char *Alpha[] = { 'A', 'B', 'C'}; instead use char Alpha[] = { 'A', 'B', 'C'}; Then you should easily be able to manipulate individual letters with Alpha[0] = 'D' or something.
Ah, Iām not 100% sure if you intended it, but the declaration you wrote for Alpha makes an array of strings[a]. If you want a string that stores a singular name as the user writes it out, (like a high-score list name or just any old text input) you probably just want to allocate an array with a specific size, and youād do that with the syntax char *Alpha[8] for a string with space for 7 characters and an end-of-string marker.
[a]: cdecl is a good tool for decoding type signatures; and strings are just pointers to char arrays in C
Most programming languagesā string libraries are built upon using dynamic allocation (i.e. finding space for variables while the program is running) to get a chunk of memory to store a stringās data. As more characters are added to the string, some library function will automatically āgrowā the string (i.e. find a new larger chunk of memory and copy-paste the old chunkās contents to that new place).
The Arduboy is so absurdly small that doing these dynamic allocations can eat up a lot of your available program space, from the sheer act of the compiler bringing in an allocator and asking the program to find space on the Arduboy to store a heap. Plus, it might be outright slower to keep finding new chunks of memory. Because of this, most developers (or at the very least, me) forgo it in favor of defining every structure before the program is run.
I dunno!! 64 characters or something? Maybe even make it a compile-time constant with #define, so you can easily change it later:
#define TEXT_INPUT_LEN 64
char Alpha[TEXT_INPUT_LEN] = { '\0' };
Just make sure to check that the userās input never exceeds that number of characters, or youāll bump up against (and possibly corrupt) other variables in your program. (Strings typically take up 1 more character than expected, as they need to store an end-of-string marker ā typically a character that is equal to ASCII 0 ā you can write it in C++ with '\0'.)
Pseudocode: Find the '\0' end-of-string marker in the array, and write characters into the array starting at that point. Once done, add the '\0' marker to the end again.
This is written in a C coding style, and is probably not the best fit for Arduboyās C++, but itāll work.
// this function is similar to C's `strnlen` function
// and you should probably use that instead!!
uint8_t find_end_of_string(char *string, uint8_t max_length) {
for (uint8_t i = 0; i < length; i++)
if (string[i] == '\0')
return i;
return max_length - 1;
}
void add_chars_to_string(char *string, char *more_chars) {
// first, find where the string's end-of-string marker is
uint8_t end_marker = find_end_of_string(string, TEXT_INPUT_LEN);
// with that marker we just found as the starting index,
// add characters from the more_chars string to the first string.
uint8_t current_char = 0;
while ( // we haven't yet reached the end of more_chars,
more_chars[current_char] != '\0'
) {
// cancel the copy if we just ran out of space
// to put the end-of-string marker byte back in.
if (end_marker + current_char + 1 >= TEXT_INPUT_LEN) return;
// copy over a character from the second string into the first!
string[end_marker + current_char] = more_chars[current_char];
current_char++;
}
// conveniently, the previous loop we did left behind the end_marker's
// next valid position, so we can set the marker with two simple lines:
end_marker = end_marker + current_char;
string[end_marker] = '\0';
}
Pseudocode: move the end-of-string marker back one byte, unless it would go outside the stringās bounds.
void backspace_string(char *string) {
uint8_t end_marker = find_end_of_string(string, TEXT_INPUT_LEN);
if (end_marker == 0) return; // oops! no more to backspace!
string[end_marker - 1] = '\0'; // replace last character with end-of-string marker.
}
And Iām out of time to keep writing this post, hahā¦ Hope this helped!
A few things to point out:
Two things:
constexpr variable is preferable to using a macro.
'\0' here, it doesnāt actually achieve anything. Empty brackets alone are enough for the array to be zero-initialised.constexpr size_t alphaCapacity = 64;
char alpha[alphaCapacity] {};
That function is missing a return. If i ever reaches length the loop will end, and thereās no return after the loop, which means the function has undefined behaviour if the provided string isnāt properly null-terminated.
Aside from which, you can just use strnlen(string, max_length), which does the same job.
(All AVR Arduino boards, including Arduboy, use avr-libc for their C standard library implementation.)
Similarly, add_chars_to_string is doing basically the same thing as strcat(destination, source), except that it doesnāt return a pointer to the new end of the string, so itāll run into the āschlemiel the painterā problem.
(Thereās also the slightly safer strlcat.)
a few of those things were on purpose to not bog down people with irrelevant details / keyboard-bash names (i cut a section about the existing programās string interning for this reason) (and i ran out of time to look over and edit the post (as this was a distraction from studying), which is why that first one was missing a return, haā¦ itās fixed now.)