How to pass reference to a string array as a function parameter in runtime when array size is unknown in C++?

Question

The following piece of code works fine. Problem is I need it to work when size of array is unknown. In the example below I have hardcoded the values to 2. In the real world I do not know the size. Is there a way to modify the code so that it works even when size of the array is not known.

void namesArray(std::string (&numList)[2], std::string name)
{
    //This is just place holder code. Please ignore the logic. 
    numList[ 0 ] = "Peter" + name;
    numList[ 1 ] = "Bruce" + name;
}

int main()
{
    std::string nameList[2];
    namesArray( nameList, "Parker");
    std::cout << nameList[0]<< std::endl;
    std::cout << nameList[1] << std::endl;
    return 0;
}

I CANNOT use any other datatype (eg: Vectors) except Arrays due to external limitations.

Edit: When I say the size is unknown, what I mean is the size of the Array is not known until runtime. Also, what I am presenting is an over simplification of my actual code. The function accepts only arrays.

UPDATE: Thank you all for the solutions offered. Looks like the code I have already authored worked in my solution. I know it's wierd to use arrays when vetors offer more flexibility. However, when dealing with legacy code you sometimes don't have a choice. THANKS A LOT FOR ALL THE ANSWERS TO EVERYONE WHO RESPONDED. IT WAS VERY INFORMATIVE.

Answer 1

If I understood your question well, you can use template mechanism to array size deduction:

#include <iostream>
#include <string>

template <size_t N>
void namesArray(std::string (&numList)[N], std::string name) {
    //This is just place holder code. Please ignore the logic.
    numList[ 0 ] = "Peter" + name;
    numList[ 1 ] = "Bruce" + name;
}

int main() {
    std::string nameList[5];
    namesArray( nameList, "Parker");
    std::cout << nameList[0]<< std::endl;
    std::cout << nameList[1] << std::endl;
    return 0;
}

Answer 2

You got presented several solutions. I'd like to present another, one that is an abstraction which incorporates several solutions. Take a gsl::span (or a std::span if you are from the future).

A span is generalized a view on a contiguous sequence of elements. And a powerful abstraction.

You want to pass an array of static size? A span can be constructed from one via a template constructor.
You want to pass a pointer and a size? span got you covered there as well.
A container like std::vector or std::array? No problem.

Use a span if all you care about is the sequence property, and not what the sequence itself is.

Answer 3

The simplest solution is to pass the size in with the array:

void namesArray(std::string *numList, std::size_t numCount, std::string name)

This will probably work for you -- you need to know the size of the array when you pass it in, but it doesn't require that you be working with a stack array from that scope, and in general usage you're more likely to have access to the size of the array than to be creating the array in the same scope that you're calling the function. It also makes things much more explicit and, if you switch to heap arrays instead of stack arrays, it still works fine.

Here's the thing: You always know the size of the array. It's literally impossible to write code that creates an array of an unknown size. You can (un)intentionally forget the array size, but at some point, it has to be known, because you literally can't create the array otherwise. You might only know it at runtime, because it's, say, defined by user input, but that just means it's in a variable, and you still know it, you just don't have it predefined at compile time.

Also, if the array size is defined at runtime, you're using heap arrays, and the other solution won't work for that.