How to get the length of a char array?

Question

How do I get the size of a set of char (char**)? The way I’m trying is always returning me the value 4.

const char* opcSalgados[] = { "Pastel", "Mini pizza", "Coxinha", "Pao de queijo", "Pao de frango com queijo", "Pao de carne" };

void ImprimeMenu(const char** menuOpc)
{
    int Length = sizeof(menuOpc[0]) / sizeof(char); // Sempre me retorna o valor 4, deveria me retornar o valor o 6
    printf("Length: %i\n", Length);

    for (int i = 0; i < Length; i++)
        printf("%i - %s\n", i + 1, menuOpc[i]);
}

Answer 1

It is possible to know the size of an array passed as an argument to a function using templates and type deduction:

template <size_t N>
void imprimeMenu(const char *(&menuOpc)[N])
{
  int Length = N;
  printf("Length: %i\n", Length);

  for (int i = 0; i < Length; ++i)
    printf("%i - %s\n", i + 1, menuOpc[i]);
}

Notice how the parameter differs with your:

template <size_t N>
void imprimeMenu(const char *(&menuOpc)[N])

In this case, we have a parameter menuOpcof the kind reference to an array of const char * fixed-size N. When passing your array opcSalgados for the function (as shown below), this template will deduce parts of the parameter type that are known at compiler time.

imprimirMenu(opcSalgados);

So given any size M of an array, type deduction will conclude that the value of N needs to be equal to M, so that the function template instance is a suitable candidate for the argument types.

It is possible to simplify this code using the container Std::array, which is effectively a fixed size array, but with a better interface:

std::array<const char *, 6> opcSalgados = {
    "Pastel", "Mini pizza",
    "Coxinha", "Pao de queijo",
    "Pao de frango com queijo", "Pao de carne"
};

template <size_t N>
void imprimeMenu(std::array<const char *, N> menuOpc)
{ /* mesma implementação… */ }

The disadvantage of using std::array is that its size needs to be specified in the template parameter (as seen in the code: std::array<const char *, 6>). If your compiler supports C++17, this problem goes away with the new deduction notes:

std::array opcSalgados = {
    "Pastel", "Mini pizza",
    "Coxinha", "Pao de queijo",
    "Pao de frango com queijo", "Pao de carne"
};

The template parameters of std::array are automatically deducted by arguments passed to the constructor.

In any case, when you know the fixed size of the array (be it a primitive array, or the container std::array), it is possible to use the loop for based on intervals (or Range-based for loop) from C++11:

template <size_t N>
void imprimeMenu(const char *(&menuOpc)[N]) // ou std::array<const char *, N>
{
  std::printf("Length: %zu\n", N);
  int i = 1;
  for (auto opcao : menuOpc)
    std::printf("%i - %s\n", i++, opcao);
}

Where auto shall be deducted for the type of menuOpc elements (in this case, const char *). That variation of for ensures that you will never have problems like accessing indexes out of array size etc.

If you need to pass other arrays with different element types, just enter one more generic type in the template parameters and use it instead of const char *:

template <typename T, size_t N>
void imprimeMenu(T(&menuOpc)[N]) // ou std::array<T, N>

Note, however, that now the implementation needs to meet any type that is deduced for T:

template <typename T, size_t N>
void imprimeMenu(T(&menuOpc)[N]) // ou std::array<T, N>
{
  std::cout << "Length: " << N << '\n'; // Aqui.
  int i = 1;
  for (auto opcao : menuOpc)
    std::cout << i++ << " - " << opcao << '\n'; // Aqui.
}

Answer 2

The compiler only knows the size of the array in its scope, in another scope it cannot know and has to pass the size by parameter.

#include <stdio.h>

void ImprimeMenu(char *menuOpc[], size_t length) {
    for (int i = 0; i < length; i++) printf("%i - %s\n", i + 1, menuOpc[i]);
}

int main(void) {
    char *opcSalgados[] = { "Pastel", "Mini pizza", "Coxinha", "Pao de queijo", "Pao de frango com queijo", "Pao de carne" };
    ImprimeMenu(opcSalgados, sizeof(opcSalgados) / sizeof(opcSalgados[0]));
}

Behold working in the ideone. And in the repl it.. Also put on the Github for future reference.