参数传递编译方法

⑴ java 中 如何通过命令行来传递参数

可以在命令行运行java程序时加上程序的参数。

例子如下：

public class HelloWorld{

public static void main(String args[]){

System.out.println("temp=" + args[0]);

}

}

源代码截图：

解释一下： String[ ] args

该参数，是一个字符串数组，用来接收从命令行输入的参数

1. 参数之间用空格隔开

2. java解释器会自动处理，把用空格隔开的每一个参数通过args数组传递给买呢（）方法。

3. 参数的下标从0开始，args[0]表示第一个参数，例如java HelloWorld 10 20 30

4.可以有多个空格，多个空格会被忽略。

(1)参数传递编译方法扩展阅读：

Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程 。

Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等 。

⑵ 参数传递的几种方式 编译原理

由于web系统采用http协议在浏览器和服务器之间传输数据，而http协议是一种无状态的协议，如何在不同页面之间传递数据，可以有一下几种方式
方式一：表单方式传递
表单传递参数是一种最简单，也是最基本的参数传递方式。注意：表单元素隐藏按钮的使用
方式二：带参数的url方式传递
带参数的url写法： url?参数名1=值1&参数名2=值2。
方式三：请求request对象
可以将数据绑定到request对象上，通过request对象getAttribute和setAttribute方法读写
方式四：用户会话session对象
可以将数据绑定到session对象上，通过session对象getAttribute和setAttribute方法读写
方式五：application对象
可以将数据绑定到application对象上，通过application对象getAttibute方法和setAttribute方法读写
方式六：cookie对象
可以将数据写到到客户端浏览器cookie文件中。

其中方式一，方式二只能实现字符串参数的传递，方式三，四，五，六可以实现对象的传递（方式六需要对象序列化后进行存储）
方式一，方式二，方式三数据传递只能请求页面获取数据，而方式四，五，六可以在多个不同页面获取数据对象
方式四和六保存的数据对象都是和某个用户相关的信息，不同的是方式四将数据保存到服务器内存中，方式六将数据保存到客户端内存中。
方式五保存的数据对象都是和所有用户相关的信息，数据也是保存到服务器内存中。

⑶ 如何在configure时，将编译参数传入，改变默认的编译器gcc成arm

按照INSTALL中的介绍,也是常用的方法，在configure的时候，加上–host=arm-linux，结果没有实现我们要的效果，没有将编译器从默认的gcc改成arm-linux-gcc，编译器还是用的默认的gcc：[[email protected]]$CFLAGS=-O2./configure–host=arm-linuxloadingcache./config.cache………………..checkingforgcc…(cached)(gcc-O2)works…(gcc-O2)isacross-compiler…no………………..后来经过多次尝试，最后受默认的CFLAGS=-O2./configure进行配置所启发，想到，是否可以将CC参数传入到configure中，结果证实，如果没有自己的cache-file，即时加了对的CC参数，也还是无法传入：[[email protected]]$CFLAGS=-O2CC=arm-linux-gcc./configure–host=arm-linuxloadingcache./config.cache………………..checkingforgcc…(cached)(gcc-O2)works…(gcc-O2)isacross-compiler……(cached)yes………………..而且，如果CC参数放在configure后面：./configureCC=arm-linux-gcc则不能识别：[[email protected]]$CFLAGS=-O2./configureCC=arm-linux-gccconfigure:warning:CC=arm-linux-gcc:invalidhosttype………………..参数传递必须像CFLAGS=-O2./configure一样，将参数设置放在configure的前面：CC=arm-linux-gcc./configure才能识别的。必须要自己制定自己的cache-file然后用./configure进行新配置，加上CC参数，才会即时生效，编译器才可以变成我们要的arm-linux-gcc:[[email protected]]$CC=arm-linux-gcc./configure–cache-file=cache_file_0–prefix=/usr/crifan/lrzsz………………..checkingforgcc…arm-linux-(arm-linux-gcc)works…(arm-linux-gcc)isacross-compiler……yes………………..否则，就无法将我们的CC参数传入了：[[email protected]]$CC=arm-linux-gcc./configure–prefix=/usr/crifan/lrzsz………………..checkingforgcc…(cached)(gcc)works…(gcc)isacross-compiler……(cached)yes………………..[[email protected]]$CFLAGS=-O2CC=arm-linux-gcc./configure–cache-file=cache_file_0loadingcachecache_file_0………………..checkingforgcc…arm-linux-(arm-linux-gcc-O2)works…(arm-linux-gcc-O2)isacross-compiler……yes最好此处在加上–prefix=/usr/crifan/lrzsz,表示具体安装到哪里[[email protected]]$CFLAGS=-O2CC=arm-linux-gcc./configure–cache-file=cache_file_0–prefix=/usr/crifan/lrzszloadingcachecache_file_0………………..checkingforgcc…arm-linux-(arm-linux-gcc-O2)works…(arm-linux-gcc-O2)isacross-compiler……yes………………..其中，/usr/crifan/lrzsz是已经建立好的，已经存在的文件夹，上面这样表示编译后，将生成的可执行文件安装拷贝到那个目录.

⑷ 如何用c语言编一个函数 实现字符串作参数传递，给个编译过的程序

st 传入子程序, st2 从子程序送回.
---------------------------
#include <stdio.h>
void show_st( char *st, char *st2){
printf("%s\n", st);
strcpy(st2,"new string !!");
}

void main()
{
char st[32]="This is string !";
char new_st[32];
show_st( &st[0], &new_st[0]);
printf("new string is: %s\n", new_st);
exit(0);
}

⑸ c语言中，带参数的主函数，如何传递参数

/*argc 表示参数个数(包括命令本身),
argv[0]就是程序命令本身,
argv[1]就是第一个参数
....*/
void main(int argc,char* argv)
{
...............
}

在命令行窗口运行:
d:\>test.exe "abc def" "world"
argv[0]就是test.exe
argv[1]就是abc def
argv[2]就是world

如果没有空格的参数可以不用加引号

⑹ ASP 编程中参数传递有几种方法

(1)、<form
action=do.asp
method=post>
<input
name=var1>
<input
type=submit>
</form>
在
do.asp
中用
request.form("var1")
取参数的值；
(2)、在
<form></form>
中
action=do.asp?var=参数值，或
<a
href=do.asp=do.asp?var=参数值></a>
然后在
do.asp
中用
request.querystring("var")
取参数的值(这是一种明文传递方式)；
(3)、使用
Cookies。设置
<%response.cookies("var")="参数值"%>，取值
<%=request.cookies("var")%>；
(4)、用
session
变量传递参数。设置<%Session("var")="参数值"%>，取值
<%=Session("var")%>
(注意：一旦使用了<%
%>
的
ASP“标志”符号，该语句就必须保存在
ASP
文件中。)

⑺ 函数的参数传递有三种方式

#include <iostream>

using namespace std;

//传值调用
void chuan(int a,int b)
{
int t=a;
a=b;
b=t;
cout<<"传值调用函数里交换完后a,b值:";
cout<<a<<" "<<b<<endl;

}

//指针传递
void zhen(int *a,int *b)
{
int t=*a;
*a=*b;
*b=t;
cout<<"指针传递函数里交换完后a,b值:";
cout<<*a<<" "<<*b<<endl;
}

//引用调用
void yinyong(int &a,int &b)
{
int t=a;
a=b;
b=t;
cout<<"引用调用函数里交换完后a,b值:";
cout<<a<<" "<<b<<endl;
}

int main()
{
int x=2,y=4;
cout<<"传值调用前:x=2,y=4"<<endl;
chuan(x,y);
cout<<"传值调用后:x="<<x<<",y="<<y<<endl<<endl;
x=2,y=4;
cout<<"指针传递前:x=2,y=4"<<endl;
zhen(&x,&y);
cout<<"指针传递后:x="<<x<<",y="<<y<<endl<<endl;
x=2,y=4;
cout<<"引用调用前:x=2,y=4"<<endl;
yinyong(x,y);
cout<<"引用调用后:x="<<x<<",y="<<y<<endl<<endl;
return 0;
}

写的有点多 运行完就 9 行

放在c++ 编译器里 运行下看看 就知道了

交换函数里面是肯定交换了,

而只有 指针传递和引用传递 才会对原来的变量值产生影响;

⑻ java中参数传递的具体步骤

有兴趣的看看这个,交流一下思想
有一根27厘米的细木杆，在第3厘米、7厘米、11厘米、17厘米、23厘米

这五个位置上各有一只蚂蚁。木杆很细，不能同时通过一只蚂蚁。开始时，蚂蚁的头朝左还是朝右是任

意的，它们只会朝前走或调头，但不会后退。当任意两只蚂蚁碰头时，两只蚂蚁会同时调头朝反方向走

。假设蚂蚁们每秒钟可以走一厘米的距离。编写程序，求所有蚂蚁都离开木杆的最小时间和最大时间。

class Student{
String name;
int id;
public Student(String name, int id) {
//super();
this.name = name;
this.id = id;
}

}

public class SendTest {

public static void main(String args[]){
int id=99;
System.out.println(id);
test1(id);

Student s=new Student("cyq",99);
test2(s);
System.out.println(s.id);
//System.out.println(s.name);
}

public static void test1(int id){

}
public static void test2(Student s){
s.id++;
}
}

这样就很清楚了吧,这样的注释,加上去,非常清楚的就完成了.

⑼ 汇编源程序与C源程序是如何进行参数传递的

llo.out,编译没错的话,就会在根目录出现一个hello.out的文件,然后 /hello.out,就可以看到结果了.

具体参阅GCC的用法

一.gcc历史

GCC最早是Richard Stallman在十几年前编写的针对于C的编译器,意思即为GNU C Compiler,后来发展支持Ada，C++,Java,Objective C,Pascal,COBOL,以及支持逻辑编程的Mercury语言，后来其英文原名变为:GNU Compiler ollection([1]).除此之外，GCC对于各种硬件平台都提供了完善的支持。

一般的，GCC的编译功能包括gcc(C的编译器),g++(C++的编译器)，在编译过程中，一共有四步工作。

1.预处理，生成i文件，C文件编译为.i文件，C++文件编译为.ii文件，它们都为源程序的预处理结果文件.以最简单的Hello World程序为例:

*********************************
// test.c
#include "stdio.h"
#define MAX 9

int main()
{
int a;
a=MAX;
printf("Hello Worldn");
}
*********************************

用cpp test.c test.i 可得到预处理文件test.i，通过查看该文件，我们可以看到，我们引入的include文件已经被引入处理，define定义的部分已经被完全带入。

2.预处理文件转换成汇编语言，生成.s文件。这一步利用egcs来完成(在mingw标准包中没有见到这个预编译器，所以测试没有成功，将继续测试）

3.汇编变为目标文件，生成.o文件,利用as来完成。

4.连接目标文件，生成可执行程序，利用ld来完成.(后续继续研究ld编译过程。)

二.GCC参数祥解

-x language filename
设定文件使用的语言，这样源程序的后缀名无效了，并对gcc后接的多个编译文件都有效。这样如 果存在.c和.cpp文件联编会有问题，解决这个问题用到了下一个参数 -x none filename,在下面做介绍。因为在预处理过程中对于.c和.cpp文件的处理方式是不一样的。可以使用的参数有:'c','objective- c','c-header','c++','cpp-output','assembler','assembler-with-cpp'.编译的时候， 如果有这样的一个用C语言写的test.tmp的文件，用gcc编译的时候就用gcc -x c test.tmp就可以让gcc用编译C语言的方式来编译test.tmp.

-x none filename
关掉上一个选项，就是让gcc根据文件名后缀，自动识别文件类型。如用下列方式编译: gcc -x c test.tmp -x none test2.c 这样可以自由地选择编译方式

-c
只激活预处理，编译和汇编，也就是把程序做成obj文件。如gcc -c test.c 就会生成test.o文件，当然这样还只是目标文件，需要经过ld连接器对所有的.o文件进行联接才能生成可执行文件.

-S
只激活预处理和编译，把文件编译到汇编代码。相当到对源程序做一个egcs操作,生成.s文件。可以查看生成的汇编文件结果。这个对于研究汇编语言的程序员来说是很有作用的。

-E
只激活预处理，这个将对文件进行预处理，将对所有引入的include文件和define定义的量进行代换，为我们开头所说的gcc 编译的第一步，即用cpp命令将程序语言文件进行预处理.但这一步不生成结果文件，如果你需要生成结果文件保存，那么需要利用系统中的输出重定向。

-o
定制目标名称，缺省的时候在unix和linux平台下gcc filename的结果是一个文件名为a.out的文件，windows下用mingw里带的gcc编译结果是a.exe。如果我们用gcc -o hello.exe test.c的话，将生成hello.exe可执行程序。这个并不一定只限于最后一步可执行程序的生成，如用上面所讲的-S生成的汇编程序也可以用-o参 数生成，比如 gcc -o hello.asm -S test.c 这样hello.asm就是test.c经过预处理和编译之后的结果。

-pipe
使用管道来代替编译中的临时文件，因为编译的整个过程有几个不同的步骤，每一个步骤都是以前一个步骤的输出为输入的，这样就涉 及到数据传递的问题，在没有-pipe参数的情况下，是用临时文件的形式来进行传递的，在有该情况的时候就利用管道来传递中间数据。当然，在某些系统中， 汇编不能读取管道数据，这样这个参数就不能正常工作了。

-ansi
关闭gnu c与ansi c不兼容的特性，激活ansi c的专有特性,在此情况下，处理器会定义一个__STRICT_ANSI__的宏，在有些头文件中会关注该宏是否被申明过，以避免某些函数的引入。此项可参照ansi c与gnu c的差别得到更多理解。

-fno-asm
此选项为ansi选项功能的一部分，禁止将asm,inline,typeof用作关键字。

-fno-strict-prototype
这个选项只对g++有作用。这个参数让编译器将所有没有参数的函数都认为是没有显式参数的个数和类型的函数，而不是没有参数。而对于gcc来说，会将没有带参数的函数认成没有显式说明的类型。

-fthis-is-variable
这个参数仅对C++程序有效,可以让this做一般变量使用，允许对this赋值.

-fcond-mismatch
允许条件表达式的第二和第三参数类型不匹配.表达式的值为void型.

-funsigned-char
-fno-signed-char
-fsigned-char
-fno-unsigned-char
这四个是对char在编译时进行的设置，它们分别决定将char设为unsigned char或signed char.

-include filename
加入头文件的位置，以使程序中顺利使用#include ，这样就可以在编译的时候这样编译:gcc test.c

-include ./include/test.h，进行联编。

-imacros filename
将filename中的宏扩展到gcc的输入文件里，宏定义本身不会出现在输入文件中。意即在编译某个文件test.c的时候，它里面申明的宏如果在没有用到该参数的时候，生成目标文件之后就会被丢弃掉，而在用了这个参数之后，这些宏将被保留用于之后文件的编译。

-Dmacro
相当于#define macro,宏的内容为字符串'1'。如在编译的时候使用gcc -o test.exe test.c -DDEBUG就相当于在test.c里面定义了DEBUG宏，值为字串'1'。可用如下程序测试可知：
**********************************
//test.c
#include "stdio.h"

int main()
{
printf("Hello Worldn");
#ifdef DEBUG
printf("hellon");
#endif
}
**********************************

如用gcc -o test.exe test.c编译，刚运行结果为:
Hello World
如用gcc -o test.exe test.c -DDEBUG编译，则运行结果为:
Hello World
hello

因此可以在下一种编译方法中相当于在test.c里面定义了DEBUG宏。

-Dmacro=define
作用同上，但设定宏的值为define.

-Umacro
相当于给程序中定义的宏作了一次undefine.即:#undef macro

-undef
取消了对任何非标准友的定义

-Idir
在#include 的时候，先在用这个参数指定的位置找头文件，如果没有找到，则到缺省的目录找头文件

-I-
取消-Idir的作用，表明以后编译的程序将不在-Idir指定的目录里寻找头文件。

-idirafter dir
在-I的目录里面查找失败之后，再在这个目录里面查找头文件，这样的参数为设置头文件查找的优先级问题比较有帮助。

-iprefix prefix
-iwithprefix dir
这两个参数一起用，在-I目录寻找失败的时候，到prefix的dir下查找头文件。

-nostdinc
编译器不再系统缺省的头文件目录里面找头文件。这样就可以精确地确定头文件的来源，应该比较慎用，在对编译器不是很了解的情况下容易造成编译失败.

-nostdinc C++
不在g++的标准路径中找头文件，但在其他的路径中继续找。在创lib的时候用。

-C
为了有效的分析程序，有预处理的时候不删除注释信息，与-E一起使用，有利用分析程序的过程。

-M
生成文件的关联的信息，这样就可以知道源代码文件里面关联了哪些它所依赖的头文件。

-MM
同上，但忽略由#include 造成的依赖关系

-MD
跟-M相当，但是输出导入到.d文件中，如gcc -MD test.c，刚输出的依赖关系存放在test.d文件里。

-MMD
跟-MM相同，但是输出到.d文件中,如gcc -MMD test.c，刚输出的依赖关系存放在test.d文件里。忽略#include 的关系

-Wa,option
这个参数将option传给汇编程序，如果option中有逗号，则会把option分成多项，传给汇编程序。

-Wl,option
这个参数将option传给连接程序，如果option中有逗号，则会把option分成多项，传给连接程序。

-llibrary
用于制定编译的时候使用的库，如 gcc -lgtk tset.c则程序使用gtk库进行编译，不过需要注意的是gcc库一般都是以libname.a来命名库文件，在用-l参数来加入库文件的时候，直接用-lname来引入，而前面的lib被省掉。这一点需要注意。

-Ldir
编译的时候设定库文件查找的路径，不然的话，编译器只在标准库路径里面找库。

-00
-01
-02
-03
编译器的优化选项，-00表示没有优化,-01为缺省值，-03为最高。

-g
在编译的时候，产生调试信息

-gstabs
以stabs格式声称调试信息，但不包括gdb的调试信息。

-gstabs+
以stabs格式声称调试信息，包括gdb的调试信息。

-ggdb
该参数将把gdb的调试信息输出

-static
这个参数将禁止使用动态库，这样程序只能连接静态库。

-share
这个参数将让程序尽量使用动态库

-traditional
试图让编译器支持传统的C语言的特性.

三.总结

gcc的参数还远远多于上面写到的这些，但是有以上的参数我们已经可以对gcc的大部分编译掌握的比较熟练了，更多的参数介绍可以参照GCC的manual，现在已有翻译了的中文手册，地址在下面的参考文献里面被列出，有兴趣的朋友可以参考。

⑽ 系统编译：如何给Make命令来传递参数

但有时候我们还是需要让make命令带入些参数给makefile脚本 比如你在代码里面需要定义个宏DEBUG来打开调试开关代码如下:{i=9;#def DEBUGi=1;#i=0;#endprf("i=%d\n", i);0;} 般来说这个宏定义可以通过直接修改源代码进行但这样显然不是很好办法 另外个办法是通过makefile修改比如: CFLAGS=-g -Wall -DDEBUG object=myprog all:$objectmyprog:a.c gcc ${CFLAGS} a.c -o ${object} 如果更进步连makefile都不想修改我们可以通过向make命令传递参数来进行为此我们需要适当修改makefile如下: CFLAGS=CFLAG CFLAGS-g -Wall -DDEBUG object=myprog all:$objectmyprog:a.c gcc ${CFLAGS} a.c -o ${object} 此时如果想打开DEBUG宏我们可以这样输入make命令: [ychq@ICM3-2 net]$ make CFLAG=-DDEBUG gcc -g -Wall -DDEBUG a.c a.c: In function `': a.c:9: warning: implicit declaration of function `prf' [ychq@ICM3-2 net]$ 我们可以发现DEBUG宏已经被正确传入 更进步我们可以通过传递区别参数给make让make编译区别模块