Rerefence to a const char* array - c++

Question

I am trying to avoid to repeat my code for 5 differentes arrays. I have 3 arrays (could be more in future):
const char *FirstlistOfOptionText[2] = {OPT_1,
OPT_2};
const char *SecondlistOfOptionText[2] = {OPT_1,
OPT_2};
const char *ThirdlistOfOptionText[2] = {OPT_1,
OPT_2};
THe elements in each one will not be the same. Now they are because I just copy&paste them. Number of elements won't neither.
I have a function in which I want to print every element of a list depending on a value I give as parameter. Also, I need to print one of those elements in other color (all in white except one in green).
I just want to have one code for printing and selecting the color as I have right now. But I want to select the correct array before doing that. I thought about:
const char *listOfOptions[];
if(menu_t.first_level_option == 0) {
listOfOptions = FirstlistOfOptionText;
}
if(menu_t.first_level_option == 1) {
listOfOptions = SecondlistOfOptionText;
}
if(menu_t.first_level_option == 2) {
listOfOptions = ThirdlistOfOptionText;
}
But I get some errors about storage size of 'listOfOptions' isn't known. Or that I can't use const char** for a char* or thing like that.
What is the correct way to do this?

Answer 1

Essentially you neeed to make listOfOptions a char **;
An array of pointers can be referenced through a pointer to pointers (that's what the char ** is).
The size will be unknown to anyone using listOfOptions thus you need a way to determine the size. Either terminate the list with a NULL pointer or you will have to use a 2nd variable (listOfOptionsSize) that tracks the size.
So the code below should compile (I opted for the NULL terminated lists).
const char *FirstlistOfOptionText[] = {"a", "b", NULL};
const char *SecondlistOfOptionText[] = {"c", "d", "e", "f", NULL};
const char *ThirdlistOfOptionText[] = {"e", "f", "g", NULL};
const char **listOfOptions= NULL; // pointer to pointer(s)
int first_level_option= 2; // some value for testing
if(first_level_option == 0) {
listOfOptions = FirstlistOfOptionText;
}
if(first_level_option == 1) {
listOfOptions = SecondlistOfOptionText;
}
if (first_level_option == 2) {
listOfOptions = ThirdlistOfOptionText;
}
printem(listOfOptions);
Now for your printing function, it will get the pointer to the list of pointers as a parameter and and will look like this:
void printem(const char **listOfOptions)
{
const char *word;
while (*listOfOptions!=NULL) { // while the pointer in the list not NULL
word= *listOfOptions; // get the char * to which listOfOptions is pointing
printf("entry: %s\n", word);
listOfOptions++;
}
}
Oh, and welcome to C-Pointer Hell :-)

Answer 2

const char *FirstlistOfOptionText[2] is an array of two pointers to char.
const char *listOfOptions[] is an array of unknown size with pointers to char.
const char **listOfOptions; is a pointer to a pointer to char and you can assign it the address of your list of options array:
listOfOptions = FirstlistOfOptionText;

Answer 3

const char *listOfOptions[];
But I get some errors about storage size of 'listOfOptions' isn't known.
The size of an array is part of its type. T[1] and T[2] are different types.
An array without a specified size is an incomplete type, and you cannot create an object of an incomplete type.
Or that I can't use const char** for a char* or thing like that.
Yes, because those are completely different types. The first is a pointer to a pointer to a constant char object. The second is a pointer to a non-constant char object.
Your code attempts to treat an array like a first-class citizen which you can assign like a "normal" object such as an int. It also attempts to treat arrays of different dimensions equally. None of that can work. C++ arrays are more limited than you think.
The solution is thus to use std::vector. And while you're at it, std::string instead of char*.
#include <string>
#include <vector>
#define OPT_1 "a"
#define OPT_2 "b"
int main()
{
std::vector<std::string> FirstlistOfOptionText = { OPT_1, OPT_2 };
std::vector<std::string> SecondlistOfOptionText = { OPT_1, OPT_2 };
std::vector<std::string> ThirdlistOfOptionText = { OPT_1, OPT_2 };
int first_level_option = 0;
std::vector<std::string> listOfOptions;
if (first_level_option == 0) {
listOfOptions = FirstlistOfOptionText;
}
if (first_level_option == 1) {
listOfOptions = SecondlistOfOptionText;
}
if (first_level_option == 2) {
listOfOptions = ThirdlistOfOptionText;
}
}
Of course, this can (and should) be improved even more. For example, getting rid of the preprocessor macros and putting the list selection into a function like std::vector<std::string> GetListOfOptions(int).

Answer 4

To print a list of options you may use a template function that takes a reference to a static array as a parameter:
template <int n>
void PrintOptions(const char* (&listOfOptions)[N])
{
for (int i = 0; i < N; i++)
{
//actual printing
}
}
void PrintMenu(/* ... */)
{
//...
switch (menu_t.first_level_option)
{
case 0:
PrintOptions(FirstlistOfOptionText);
break;
case 1:
PrintOptions(SecondlistOfOptionText);
break;
case 2:
PrintOptions(ThirdlistOfOptionText);
break;
}
//...
}
The size of an array will be deduced by the compiler.