命令行参数与getopt函数
 
getopt用来解析命令行选项参数。
 
（1）原型：
 
int getopt(int argc, char * const argv[], const char *optstring);
 调用一次，返回一个选项。在命令行选项参数再也检查不到optstring中包含的选项时，返回－1，同时optind储存第一个不包含选项的命令行参数。
 
（2）涉及的参数及头文件
 
#include <unistd.h>
 extern char *optarg;  //选项的参数指针
 extern int optind, //下一次调用getopt的时，从optind存储的位置处重新开始检查选项。 
 extern int opterr,  //当opterr=0时，getopt不向stderr输出错误信息。
 extern int optopt;  //当命令行选项字符不包括在optstring中或者选项缺少必要的参数时，该选项存储在optopt中，getopt返回'？’。
 
（3）optstring参数
 
字符串optstring可以是下列元素：
 1.单个字符，表示选项；
 2.单个字符后接一个冒号：表示该选项后必须跟一个参数。参数紧跟在选项后或者以空格隔开。该参数的指针赋给optarg；
 3.单个字符后跟两个冒号，表示该选项后必须跟一个参数。参数必须紧跟在选项后不能以空格隔开。该参数的指针赋给optarg。（这个特性是GNU的扩张）。
 
（4）optstring参数举例
 
getopt处理以'-’开头的命令行参数，如optstring="ab:c::d::",命令行为getopt.exe -a -b host -ckeke -d haha
 在这个命令行参数中，-a、-b和-c就是选项元素，去掉'-'，a,b,c就是选项。host是b的参数，keke是c的参数。但haha并不是d的参数，因为它们中间有空格隔开。
 
还要注意的是默认情况下getopt会重新排列命令行参数的顺序，所以到最后所有不包含选项的命令行参数都排到最后。如getopt.exe -a ima -b host -ckeke -d haha, 都最后命令行参数的顺序是： -a -b host -ckeke -d ima haha。
 如果optstring中的字符串以'+'加号开头或者环境变量POSIXLY_CORRE被设置。那么一遇到不包含选项的命令行参数，getopt就会停止，返回-1。
 
 

 
java中的命令行参数
 

  

  

 
 
Command-line arguments in Java are used to pass arguments to the main program. If you look at the Java main method syntax, it accepts String array as an argument.
 
 Java中的命令行参数用于将参数传递给主程序。 如果您查看Java main方法的语法，它将接受String数组作为参数。 
 
 
When we pass command-line arguments, they are treated as strings and passed to the main function in the string array argument. The arguments have to be passed as space-separated values.
 
 当我们传递命令行参数时，它们被视为字符串并传递给字符串数组参数中的main函数。 参数必须以空格分隔的值传递。 
 
 

 
 
 
We can pass strings and primitive data types as command-line arguments. The arguments will be converted to strings and passed into the main method string array argument.
 
 我们可以将字符串和原始数据类型作为命令行参数传递。 参数将转换为字符串，并传递给主方法字符串数组参数。 
 
 
 Java中的命令行参数 (Command Line Arguments in Java)
 
 
Let’s say we have a simple java class to print command line arguments values.
 
 假设我们有一个简单的java类来打印命令行参数值。 
 
 
package com.journaldev.examples;

public class CommandLineArguments {

	public static void main(String[] args) {
		System.out.println("Number of Command Line Argument = "+args.length);
		
		for(int i = 0; i< args.length; i++) {
			System.out.println(String.format("Command Line Argument %d is %s", i, args[i]));
		}
	}

}
 
If we run this class without any arguments, the output will be as follows.
 
 如果我们在不带任何参数的情况下运行此类，则输出将如下所示。 
 
 
$ java com/journaldev/examples/CommandLineArguments.java
Number of Command Line Argument = 0
 
Now, let's pass some arguments to the main class. We have to pass the arguments as space-separated values.
 
 现在，让我们将一些参数传递给主类。 我们必须将参数作为以空格分隔的值进行传递。 
 
 

  

  

 
 
$ java com/journaldev/examples/CommandLineArguments.java "A" "B" "C"
Number of Command Line Argument = 3
Command Line Argument 0 is A
Command Line Argument 1 is B
Command Line Argument 2 is C
$ java com/journaldev/examples/CommandLineArguments.java 1 2 3      
Number of Command Line Argument = 3
Command Line Argument 0 is 1
Command Line Argument 1 is 2
Command Line Argument 2 is 3
$
 

  Note: If you are using 
  注意 ：如果使用的是
  Java 11 or higher, you don't need to compile the java source file explicitly. The java command will compile and run the class simultaneously.
  Java 11或更高版本，则无需显式编译Java源文件。 java命令将同时编译并运行该类。 
 
 
 如何在Eclipse中传递命令行参数 (How to Pass Command Line Arguments in Eclipse)
 
 
We can also pass command-line arguments to a program in Eclipse using Run Configurations.
 
 我们还可以使用“运行配置”将命令行参数传递给Eclipse中的程序。 
 
 
 步骤1：打开“类运行配置”设置 (Step 1: Open the Class Run Configurations Settings)
 
 
From the class editor, right click and chose "Run As" -> "Run Configurations...".
 
 在类编辑器中，右键单击并选择“运行方式”->“运行配置...”。 
 
 

  

  

 
 

  
  
Eclipse Run Configurations
  
 Eclipse运行配置 
 
 
 
 步骤2：在“参数”选项卡中指定程序参数 (Step 2: Specify the Program Arguments in the Arguments Tab)
 
 
In the pop up window, click on the Arguments tab. Then provide the command line arguments value in the "Program Arguments" text box.
 
 在弹出窗口中，单击“参数”选项卡。 然后在“程序参数”文本框中提供命令行参数值。 
 
 

  
  
Eclipse Command Line Arguments
  
 Eclipse命令行参数 
 
 
 
 步骤3：点击“运行”按钮 (Step 3: Click on the Run button)
 
 
When you will click on the Run button, the run configurations will be saved and the program will execute with the specified command-line arguments.

 
 当您单击“运行”按钮时，将保存运行配置，并且程序将使用指定的命令行参数执行。 
 
 

  
  
Eclipse Command Line Arguments Example
  
 Eclipse命令行参数示例 
 
 
 

   If you run the class again, the saved run configuration will be used. So if you want to override the command-line arguments or remove them, you will have to open the run configurations window and make necessary changes.
 
 

   如果再次运行该类，将使用保存的运行配置。 因此，如果要覆盖或删除命令行参数，则必须打开运行配置窗口并进行必要的更改。 
 
 
 
 结论 (Conclusion)
 
 
The command-line arguments are used to provide values that are essential to run the program. For example, we can specify the database credentials to be used by the program. We can specify the configuration file location from where the program should pick the required values.
 
 命令行参数用于提供运行程序必不可少的值。 例如，我们可以指定程序要使用的数据库凭据。 我们可以指定程序应从中选择所需值的位置的配置文件位置。 
 
 
Reference: Command-Line Arguments Oracle Docs
 
 参考： 命令行参数Oracle Docs 
 
 

  
翻译自: https://www.journaldev.com/32004/command-line-arguments-in-java
 
 
java中的命令行参数

 
Python 命令行参数详解
 
0. 命令行参数
1. sys.argv
2. getopt
2.1 getopt.getopt 方法
2.2 Exception getopt.GetoptError
   
3. argparse
 

 
0. 命令行参数
 
通常，对于大型项目程序而言，执行程序的一个必要的步骤是正确处理命令行参数，这些命令行参数是提供给包含某种参数化信息的程序或脚本的参数。例如，在计算机视觉项目中，图像和不同类型的文件通常作为命令行参数传递给脚本，用于使程序可以处理不同图片或者不同类型文件。
 命令行参数是参数化程序执行的一种常见且简单的方法，下面主要介绍三种常见的获取和解析命令行参数的方法。
 
1. sys.argv
 
为了处理命令行参数，Python 中内置了 sys.argv 模块，通过模块中的 sys.argv 就可以访问到所有的命令行参数，它的返回值是包含所有命令行参数的列表 (list)。当程序执行时，Python 从命令行获取所有值并将它们存储在 sys.argv 列表中。列表的第一个元素 sys.argv[0] 是脚本的完整路径(或脚本名称——取决于具体操作系统)。列表的第二个元素是脚本的第一个命令行参数，即 sys.argv[1]，依此类推。这可以通过下图中清晰的看出，其中 script_1.py 脚本使用两个参数执行：
 

 接下来，让我们看看 sys.argv 是如何工作的，首先编写 scripy_1.py 脚本：
 
import sys
print("正在运行的脚本名称: '{}'".format(sys.argv[0]))
print("脚本的参数数量: '{}'".format(len(sys.argv)))
print("脚本的参数: '{}'".format(str(sys.argv)))
 
如果我们不使用任何参数执行这个脚本：
 
python script_1.py
 
将会看到如下信息：
 
正在运行的脚本名称: 'script_1.py'
脚本的参数数量: '1'
脚本的参数: '['script_1.py']'
 
如果我们使用多个参数执行此脚本:
 
python script_1.py OpenCV -i test.png
 
将得到以下信息：
 
正在运行的脚本名称: 'script_1.py'
脚本的参数数量: '4'
脚本的参数: '['script_1.py', 'OpenCV', '-i', 'test.png']'
 
如上所示，列表的第一个元素 script_1.py (sys.argv[0]) 是脚本名称。列表的第二个元素 (sys.argv[1]) OpenCV 是脚本的第一个参数。但同时也可以看到，sys.argv 将命令行选项 -i 也识别为参数，这样并不能方便的满足我们的需求，因此引入 getopt 模块来识别命令行选项。
 
2. getopt
 
getopt 模块是专门处理命令行参数的模块，用于获取命令行选项和参数。命令行选项使得程序的参数更加灵活，其支持短选项模式(-)和长选项模式(–)。
 该模块提供了两个方法及一个异常处理来解析命令行参数。
 
2.1 getopt.getopt 方法
 
getopt.getopt 方法用于解析命令行参数列表，其语法格式如下：
 
getopt.getopt(args, options[, long_options])
 
方法参数说明如下表所示：
 
参数
说明
args
要解析的命令行参数列表，一般是sys.argv[1:]，需要过滤掉脚本名(sys.argv[0])
options
以字符串的格式定义，options 后的冒号 “:” 表示如果设置该选项，必须有附加的参数，否则就不附加参数
long_options
以列表的格式定义，long_options 后的等号 “=” 表示该选项必须有附加的参数，不带冒号表示该选项不附加参数
该方法返回值由两个元素组成: 第一个是 (option, value) 元组的列表。 第二个是参数列表，包含那些没有 - 或 – 的参数。
 下面编写 script_2.py 脚本进行演示：
 
import sys
import getopt


def main(argv):
    input_file = ""
    output_file = ""
    # "hi:o:": 短格式分析串, h 后面没有冒号, 表示后面不带参数; i 和 o 后面带有冒号, 表示后面带参数
    # ["help", "input_file=", "output_file="]: 长格式分析串列表, help后面没有等号, 表示后面不带参数; input_file和output_file后面带冒号, 表示后面带参数
    # 返回值包括 `opts` 和 `args`, opts 是以元组为元素的列表, 每个元组的形式为: (选项, 附加参数)，如: ('-i', 'test.png');
    # args是个列表，其中的元素是那些不含'-'或'--'的参数
    opts, args = getopt.getopt(argv[1:], "hi:o:", ["help", "input_file=", "output_file="])

    for opt, arg in opts:
        if opt in ("-h", "--help"):
            print('script_2.py -i <input_file> -o <output_file>')
            print('or: test_arg.py --input_file=<input_file> --output_file=<output_file>')
            sys.exit()
        elif opt in ("-i", "--input_file"):
            input_file = arg
        elif opt in ("-o", "--output_file"):
            output_file = arg
    print('输入文件为：', input_file)
    print('输出文件为：', output_file)

    # 打印不含'-'或'--'的参数
    for i in range(0, len(args)):
        print('不含'-'或'--'的参数 %s 为：%s' % (i + 1, args[i]))
        
if __name__ == "__main__":
    main(sys.argv)
 
使用带有命令行选项的命令执行此脚本，以下两种方式是等价的：
 
# 方式1
python scripy_1.py -i test.png -o output.png OpenCV
# 方式2
python scripy_1.py --input_file test.png --output_file output.png OpenCV
 
输出得到以下信息：
 
输入文件为： test.png
输出文件为： output.png
不含'-'或'--'的参数 1 为：OpenCV
 
2.2 Exception getopt.GetoptError
 
在参数列表中没有找到所传递参数，或选项的需要的参数为空时会触发该异常。异常的参数是一个字符串，表示错误的原因。属性 msg 和 opt 为相关选项的错误信息。
 在上述代码中添加异常处理，检查此错误信息：
 
# ...
def main(argv):
    input_file = ""
    output_file = ""
    try:
        opts, args = getopt.getopt(argv[1:], "hi:o", ["help", "input_file=", "output_file="])
    except getopt.GetoptError as e:
        print(e.msg)
        print(e.opt)
        sys.exit(2)
# ...
 
使用错误的格式选项传递参数执行脚本：
 
python scripy_1.py -f
 
输出以下错误信息：
 
option -f not recognized
f
 
3. argparse
 
当程序中使用采用复杂参数或多个文件名时，推荐使用 Python 的 argparse 库，它以系统的方式处理命令行参数，从而可以编写用户友好的命令行程序。Python 标准库 argparse 同样也是用于解析命令行参数的模块。首先，由程序确定所需的参数，然后， argparse 将这些参数解析为 sys.argv。此外，argparse 会生成帮助和使用信息提示，并在提供无效参数时发出错误。
 为了介绍此模块，编写 script_3.py，如下所示：
 
import argparse
parser = argparse.ArgumentParser()
parser.parse_args()
 
不带参数运行此脚本不会向 stdout 显示任何内容。但是，如果使用 --help 或 -h 选项，将得到脚本的使用信息提示：
 
usage: scripy_3.py [-h]
optional arguments:
-h, --help show this help message and exit
 
指定其他参数会导致错误，例如使用如下命令：
 
scripy_3.py -i
 
则会报导致错误：
 
usage: scripy_3.py [-h]
argparse_minimal.py: error: unrecognized arguments: -i
 
由于未定义参数，因此不允许其他参数，接下来就添加一个参数，编写 script_4.py 脚本：
 
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("first_argument", help="this is the string text in connection with first_argument")
args = parser.parse_args()
print(args.first_argument)
 
这里添加了 add_argument() 方法。此方法用于指定程序将接受哪些命令行选项，此处添加了 first_argument 参数。此外， argparse 模块存储所有参数，将其名称与每个添加参数的名称相匹配——在此处为 first_argument 。为了获得参数值，需要使用 args.first_argument。
 如果此脚本以下示方法执行，则输出为 10：
 
python scripy_4.py 10
 
但如果脚本在没有参数的情况下执行，则将输出以下信息：
 
usage: scripy_4.py [-h] first_argument
scripy_4.py: error: the following arguments are required: first_argument
 
最后，如果我们使用 -h 选项执行脚本，输出将如下所示：
 
usage: scripy_4.py [-h] first_argument

positional arguments:
  first_argument  this is the string text in connection with first_argument

optional arguments:
  -h, --help      show this help message and exit
 
默认情况下，argparse 将提供的选项视为字符串。因此，如果参数不是字符串，则应使用 type 选项。使用 script_5.py 脚本，其中添加了两个参数，这两个参数是 int 类型：
 
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("first_number", help="first number to be added", type=int)
parser.add_argument("second_number", help="second number to be added", type=int)
args = parser.parse_args()
print("args: '{}'".format(args))
print("the sum is: '{}'".format(args.first_number + args.second_number))
args_dict = vars(parser.parse_args())
print("args_dict dictionary: '{}'".format(args_dict))
print("first argument from the dictionary: '{}'".format(args_dict["first_number"]))
 
在前面的示例中，通过调用 vars() 函数将参数存储在字典中：
 
args_dict = vars(parser.parse_args())
print("args_dict dictionary: '{}'".format(args_dict))
print("first argument from the dictionary: '{}'".format(args_dict["first_number"]))
 
如果不带参数执行脚本：
 
python script_5.py
 
则输出如下：
 
usage: scripy_5.py [-h] first_number second_number
scripy_5.py: error: the following arguments are required: first_number, second_number
 
此外，如果我们使用 -h 选项执行脚本：
 
python script_5.py --help
 
输出将如下所示：
 
usage: scripy_1.py [-h] first_number second_number

positional arguments:
  first_number   first number to be added
  second_number  second number to be added

optional arguments:
  -h, --help     show this help message and exit
 
如果此脚本以如下方式执行：
 
python script_5.py 123 456
 
则输出如下：
 
args: 'Namespace(first_number=123, second_number=456)'
the sum is: '579'
args_dict dictionary: '{'first_number': 123, 'second_number': 456}'
first argument from the dictionary: '123'
 
更多 argparse 的高级介绍可以在官方文档中看到，其中包括了大量示例。

 
c语言+命令行参数
 

  

  

 
 
In this article, we’ll be looking at how we can use command line arguments in C / C++.
 
 在本文中，我们将研究如何在C / C ++中使用命令行参数。 
 
 
Command Line arguments are very useful if you want to pass any input strings to your main program, from the command line.
 
 如果要从命令行将任何输入字符串传递到主程序，则命令行参数非常有用。 
 
 

 
 
 
These arguments are passed as parameters to the main() function.
 
 这些参数作为参数传递给main（）函数。 
 
 
Let’s look at how we can use these effectively.
 
 让我们看看如何有效地使用它们。 
 
 

 
 
 
 为什么要使用命令行参数？ (Why should we use command line arguments?)
 
 
Often, it is very convenient for us to directly give input to our program. One common way is to use scanf() / getchar(), etc to wait for a user input.
 
 通常，对于我们而言，直接向程序提供输入非常方便。 一种常见的方法是使用scanf() / getchar()等来等待用户输入。 
 
 
But, these calls waste a lot of time in waiting, and requires the user to manually enter the input.
 
 但是，这些呼叫浪费大量时间等待，并且需要用户手动输入输入。 
 
 

  

  

 
 
We can save a lot of time by simply giving these inputs to our main program!
 
 通过将这些输入提供给我们的主程序，我们可以节省大量时间！ 
 
 
The format will be something like:
 
 格式如下： 
 
 

./executable input1 input2

 
The program will automatically store those command-line arguments in special variables, from which we can access them directly!
 
 该程序将自动将这些命令行参数存储在特殊变量中，我们可以从中直接访问它们！ 
 
 
This will only require a one time input, given when we start our program.
 
 启动程序时，只需输入一次即可。 
 
 
Let’s look at how we can use them now.
 
 让我们看看现在如何使用它们。 
 
 
 C / C ++中的命令行参数–特殊变量 (Command Line Arguments in C/C++ – The special variables)
 
 
The program will pass the command line arguments to the main() function.
 
 该程序会将命令行参数传递给main()函数。 
 
 
In C / C++, the main() function takes in two additional parameters for these arguments.
 
 在C / C ++中，main（）函数为这些参数引入了两个附加参数。 
 
 
argc -> Argument Count. Gives the number of arguments that we pass (includes the program name also)
 argc >参数计数。 给出我们传递的参数数量（还包括程序名称） 
argv -> Argument Vector. This is a char* array of strings. These are the argument values itself.
 argv >参数向量。 这是一个char*字符串数组。 这些是参数值本身。 
 
So, argv[0] is the name of the program itself, and argv[1] … argv[argc-1] will be all our command line arguments.
 
 因此， argv[0]是程序本身的名称，而argv[1] … argv[argc-1]将是我们的所有命令行参数。 
 
 

  

  

 
 

int main(int argc, char* argv[]);

 
To see this in action, let’s take an example.
 
 为了了解这一点，让我们举个例子。 
 
 

 
 
 
 使用命令行参数–一个简单的例子 (Using command line arguments – A simple example)
 
 
Let’s consider a program which concatenates two strings, given as input.
 
 让我们考虑一个程序，该程序将两个字符串作为输入给出。 
 
 
We’ll pass in two command line arguments to our program, so our total argc must be 3 (including the program name).
 
 我们将两个命令行参数传递给我们的程序，因此我们的总argc必须为3（包括程序名）。 
 
 
We can write our program like this:
 
 我们可以这样编写程序： 
 
 

#include <iostream> 
#include <string>

using namespace std;

string concat_strings(string s1, string s2) {
    return s1 + s2;
}

int main(int argc, char* argv[]) 
{ 
    cout << "You have entered " << argc 
         << " arguments:" << "\n";

    if (argc != 3) {
        cerr << "Program is of the form: " << argv[0] << " <inp1> <inp2>\n";
        return 1;
    } 

    string result = concat_strings(argv[1], argv[2]);

    cout << "Result: " << result << endl;

    return 0; 
} 

 
If our executable name was test.out, on my linux machine, I run the executable using this command:
 
 如果我们的可执行文件名为test.out ，则在我的Linux机器上，我使用以下命令运行可执行文件： 
 
 

./test.out Hello _JournalDev

 
Notice that the arguments are space-separated. So our command-line arguments are: “Hello” and “_JournalDev”
 
 请注意，参数以空格分隔。 因此，我们的命令行参数为：“ Hello”和“ _JournalDev” 
 
 
Output
 
 输出量 
 
 

You have entered 3 arguments:                                                                                                
Result: Hello_JournalDev

 
Great! This seems to work as expected, since the first argument is the name of the program itself.
 
 大！ 这似乎按预期工作，因为第一个参数是程序本身的名称。 
 
 
Let’s try to run this with 4 arguments now.
 
 现在让我们尝试使用4个参数运行它。 
 
 

./test.out Hello from JournalDev

 
Output
 
 输出量 
 
 

You have entered 4 arguments:                                                                                                
Program is of the form: ./test.out <inp1> <inp2>

 
Indeed, it gives us the correct error message!
 
 确实，它为我们提供了正确的错误消息！ 
 
 

 
 
 
 结论 (Conclusion)
 
 
Hope this article gives you a better understanding of command line arguments. We saw how we can use it to make our lives easier!
 
 希望本文能使您对命令行参数有更好的了解。 我们看到了如何使用它来使我们的生活更轻松！ 
 
 
For similar content, do go through our tutorial section on C++ programming.
 
 对于类似的内容，请阅读我们有关C ++编程的教程部分 。 
 
 
 参考资料 (References)
 
 
cplusplus.com post on Command Line arguments in C++
 cplusplus.com关于C ++命令行参数的文章 
 

 
 
 

  
翻译自: https://www.journaldev.com/41869/command-line-arguments-c-plus-plus
 
 
c语言+命令行参数