动态一维数组作为输入

Question

I am trying to get a dynamic 1D array of integers as input. The situation is I do not know how many inputs I would have. I have the following code, but I know its wrong. Could you please tell me how I can achieve this?

     int main(string path,string aligned_path,vector<int>cams)
     {
        string path = "/home/iiith/resect/output.txt";
        findpoints(cams,path);
     } 

The size of cams is actually unknown. I would not know how many cams they would provide as input. Am trying to achieve something like the below

    ./a.out path1 path2 1 2 3 5 6

The numbers trailing in the end would be the cams. it can be any number of cams. Is it possible to receive them all as input? is it possible to have an inut parameter that is dynamic as the above.? Please help me here. It would b really helpful. Thanks in Advance

Answer 1

Your definition of main is invalid. In C and C++, main has a strict definition (although arguments can be ignored if not used):

int main(int argc, char **argv)

A common extension is to also pass in environment variables:

int main(int argc, char **argv, char **envp)

and if arguments aren't used at all:

int main()

The arguments to main are defined as follows argc is the number of elements in the list of arguments. Each of the following argv[0] .. argv[argc-1] contain the arguments to your function. argv[0] is the name of the executable itself. argv[1] with your example would be path1 .

So, you know how many cams there are based on argc . Of course, you have to copy the string values in argv[x] into the relevant place in a vector, using, perhaps, std::stoi(...) to make it into an integer value.

Answer 2

The signature of main must be int main(int argc, char* argv[]) (or equivalent, or int main() ). You would process the arguments into something more useful within your own code. Here's a quick and sloppy example (no proper error handling, etc).

#include <iostream>
#include <cstdlib>
#include <vector>

int main(int argc, char * argv[])
{
    std::vector<int> nums;
    nums.reserve(argc-3);
    int pos = 3;

    // Read args into vector of ints
    while (pos < argc)
    {
        nums.push_back(atoi(argv[pos]));
        ++pos;
    }

    // Print them
    for (auto i : nums) std::cout << i << '\n';
}

Here's a run:

$ ./a.out path1 path2 1 2 3 5 4
1
2
3
5
4

Just in case it isn't clear: argc contains the number of arguments passed, including the name of the program. so for $ ./a.out argc=1 , for $ ./a.out some list of args argc=5 .

Then argv is an array of c -style strings ( NUL -terminated const char * s) containing the text of each argument.

Note that strictly speaking the argv array is 1 longer than it needs to be, and the last entry is guaranteed to be a NULL pointer.

---

For Standard geeks, I don't have the proper C++ 2011 standard, this is from N3337:

3.6.1 Main function

...

2 An implementation shall not predefine the main function. This function shall not be overloaded. It shall have a return type of type int , but otherwise its type is implementation-defined. All implementations shall allow both of the following definitions of main :

int main() { /* ... */ }

and

int main(int argc, char* argv[]) { /* ... */ }

In the latter form argc shall be the number of arguments passed to the program from the environment in which the program is run. If argc is nonzero these arguments shall be supplied in argv[0] through argv[argc-1] as pointers to the initial characters of null-terminated multibyte strings (ntmbs s) (17.5.2.1.4.2) and argv[0] shall be the pointer to the initial character of a ntmbs that represents the name used to invoke the program or "". The value of argc shall be non-negative. The value of argv[argc] shall be 0 . [ Note: It is recommended that any further (optional) parameters be added after argv . —end note ]