C++ 缺省函数参数

C++缺省函数参数

缺省参数同函数重载一样，给程序员提供了很多方便，它们都使我们可以在不同的场合使用同一名字。不同之处是，当我们不想亲手提供这些值时，由编译器提供一个缺省参数。有时可用缺省参数代替函数重载。用函数重载我们得把一个几乎同样含义、同样操作的函数写两遍甚至更多。当然，如果函数之间的行为差异较大，用缺省参数就不合适了。

在使用缺省参数时需注意以下几点。

1.只有参数列表的后部参数才可是缺省的，也就是说，我们不可以在一个缺省参

数后面又跟一个非缺省的参数。

2.一旦我们开始使用缺省参数，那么这个参数后面的所有参数都必须是缺省的。

（从左至右，第一个为缺省，则所有均为缺省参数。）

3.缺省参数只能放在函数声明中，通常在一个头文件中。编译器必须在使用该函

数之前知道缺省值。

4.小小补充：函数定义与原型（声明）中的参数名称可以不同，编译器只检查参

数类型是否相同；相同，编译通过；反之，不通过；

要说明的是，上述3是很多课本和视频教程里谈到的，关于这个说法应该怎样去理解呢??

我想可以这样理解:函数的实现（定义）本来就与参数是否有缺省值无关，所以没有必要让缺省值出现在函数的定义体中。其次参数的缺省值可能会改动，显然修改函数的声明比修改函数的定义要方便。但是如果我们不遵循这样的一个规则，编译器仍然是能通过的。例如：

上面如果把实现文件的函数加上缺省参数值，无论是否int y=0还是其他值都会发生编译错误：error C2572:“father::print”:重定义默认参数:参数

C++中虚函数中的默认参数问题

当通过指针调用一个对象的方法时，如果该方法是虚函数，则实际调用的是该实例的方法。

当缺省参数和虚函数一起出现的时候到底用哪个默认值呢？虚函数是动态绑定的，但是为了执行效率，缺省参数是静态绑定的。

也就是指针是哪种类型，就调用该类型对应的类中，该函数定义时的缺省值。

由上可知pa->out()和pa->out(3)调用都是函数A::out(int i)，

由上可知pb->out()和pb->out(4)调用都是函数B::out(int i)，

缺省参数是静态绑定的，pb->out()时，pb的静态类型是A*，它的缺省参数是1；但是调用的是B::out(int i)

上面得输出如下

1.enum ShapeColor{RED,GREEN,BLUE};

2.

3.//一个表示几何形状的类

4.

5.class Shape{

6.

7.public:

8.

9.//所有的形状都要提供一个函数绘制它们本身

10.

11.virtual void draw(ShapeColor color=RED)cons

t=0;

12.

13....

14.

15.};

16.

17.class Rectangle:public Shape{

18.

19.public:

20.

21.//注意：定义了不同的缺省参数值----不好!

22.

23.virtual void draw(ShapeColor color=GREEN)co

nst;

24.

25....

26.

27.};

28.

29.class Circle:public Shape{

30.

31.public:

32.

33.virtual void draw(ShapeColor color)const;

34.

35....

36.

37.};

用图形来表示是下面这样：

Shape

//

//

//

Rectangle Circle

现在看看这些指针：

Shape*ps;//静态类型=Shape*

Shape*pc=new Circle;//静态类型=Shape*

Shape*pr=new Rectangle;//静态类型=Shape*

这个例子中，ps，pc，和pr都被声明为Shape指针类型，所以它们

都以此作为自己的静态类型。注意，这和它们真的所指向的对象的类型绝对没有关系----它们的静态类型总是Shape*。

对象的动态类型是由它当前所指的对象的类型决定的。即，对象的动

态类型表示它将执行何种行为。上面的例子中，pc的动态类型是Circle*，pr的动态类型是Rectangle*。至于ps，实际上没有动态类型，因为它（还）没有指向任何对象。

动态类型，顾名思义，可以在程序运行时改变，典型的方法是通过赋值：

ps=pc;//ps的动态类型

//现在是Circle*

ps=pr;//ps的动态类型

//现在是Rectangle*

虚函数是动态绑定的，意思是说，虚函数通过哪个对象被调用，具体

被调用的函数就由那个对象的动态类型决定：

pc->draw(RED);//调用Circle::draw(RED)

pr->draw(RED);//调用Rectangle::draw(RED)

我知道这些都是老掉牙的知识了，你当然也了解虚函数。（如果想知

道它们是怎么实现的，参见条款M24）但是，将虚函数和缺省参数值结

合起来分析就会产生问题，因为，如上所述，虚函数是动态绑定的，但缺省参数是静态绑定的。这意味着你最终可能调用的是一个定义在派生类，但使用了基类中的缺省参数值的虚函数：

pr->draw();//调用Rectangle::draw(RED)!

这种情况下，pr的动态类型是Rectangle*，所以Rectangle的虚函数被

调用----正如我们所期望的那样。Rectangle::draw中，缺省参数值是GREEN。但是，由于pr的静态类型是Shape*，这个函数调用的参数值是从Shape类中取得的，而不是Rectangle类！所以结果将十分奇怪并且出

人意料，因为这个调用包含了Shape和Rectangle类中Draw的声明的组合。你当然不希望自己的软件以这种方式运行啦；至少，用户不希望这样，相信我。

不用说，ps，pc，和pr都是指针的事实和产生问题的原因无关。如果它们是引用，问题也会继续存在。问题仅仅出在，draw是一个虚函数，

并且它的一个缺省参数在子类中被重新定义了。

为什么C++坚持这种有违常规的做法呢？答案和运行效率有关。如果

缺省参数值被动态绑定，编译器就必须想办法为虚函数在运行时确定合适的缺省值，这将比现在采用的在编译阶段确定缺省值的机制更慢更复杂。做出这种选择是想求得速度上的提高和实现上的简便，所以大家现在才能

感受得到程序运行的高效；当然，如果忽视了本条款的建议，就会带来混乱。

先说一下现在的C++的参数传递机制，非虚函数和虚函数的传递机制都是一样的。

比如如下函数调用：

func(10);

会被编译器翻译成：

push10

puch返回地址

call func

大概就是这样：先把参数压栈，然后压返回地址，在调用函数。

对于虚函数来说，如果调用时没有指定参数值，那么编译器会帮我们加上去。

对，加上去，这里就有问题来了，如果是用基类指针调用的虚函数，我们知道，因为动态绑定，编译器暂时无法知道实际调用的是哪个函数，所以他得用虚函数的机制进行2此指针操作在实际的类地址中找到虚函数表，再根据偏移找到实际的函数跳转地址，而此时，编译器必须提前把参数压栈准备好，call之后就直接用参数了。

那么，既然编译器还不知道实际调用的是哪个函数，那么当然就更不知道实际传递的默认参数应该是子类还是父类的了。关键就在这里。

参数都是静态绑定的，如果要动态，上文说了，效率会跟虚函数调用一样稍微有点低，所以C++折中了。

话又说回来，如果要动态的实现，怎么办呢？？？下面说点个人的思路

对，虚函数动态绑定是用vptbl实现的(这个《深度探索c++对象模型》中有)，那么默认参数的实现是否也能参考呢？？应该可以。

编译器可以把一条压栈（压默认参数值的指令）放在函数代码的前面几条指令中，

然后在跳转的时候，实际的call指令可以延后几句，这样：

用effective中的例子：

pr->draw();

编译后可能是：

//因为没有指定参数，所以在我们的尝试实现中不压参数

call(*pr->_vtbl[2]-4)//这个计算虚函数地址的我简单写到一行了，实际上时2个取指操作。-4的原因待会说。

当然，函数代码也得相应的改变一下:

push GREEN

Rectangle::draw：//这才是真正的draw代码，上述-4的原因就是为

了执行上面的push GREEN指令，这，同理在基类中代码也会变成这样：

push RED

Shape::draw://Shape的draw代码

总结一下，就是说把参数压栈的指令稍微改一下，如果正常传递了参数当然就不用了，如果没传递参数，那么在函数的代码之前加上一句压

参数指令，然后在函数跳转的时候，往回多跳一条指令，让实际掉用的

代码去压这个参数。

说的可能有的乱，有些错的地方还忘见谅。呵呵···

Derive*pd=&de;//得到一个指向de的Derive 指针

pd->Func();//通过指针调用Func()

这种情况下，如果Derive没有重新定义Func函数时，两个指针调用Func的行为是相同的；但是，如果Func 是非虚函数且Derive又重新定义了自己的Func版本，那么两者的行为就不会相同了：

class Derive:public Base

{

public:

void Func();//隐藏了Base::Func;

...

};

pb->Func();//调用Base::Func()

pd->Func();//调用Derive::Func()

这种行为的两面性原因在于：Base::Func()和Derive::Func()这样的非虚函数是静态绑定的。因此，即使pb指向的是从Base派生的类的对象，但由于pb 被声明为执行Base的指针类型，所以通过pb调用非虚函数时就总是调用那些定义在类Base中的函数。

与之相反，虚函数是动态绑定的，不会存在上述问题。通过pb或pd调用Func()时都将导致调用

Derive::Func()，因为pb和pd实际上都是指向类型Derive的对象。

结论：如果写派生类Derive时重新定义从基类Base继承而来的非虚函数Func()，Derive的对象就可能表现出精神分裂的症状。引用也会和指针一样表现出这种异常行为。

因此，任何情况下都要禁止重新定义继承而来的非虚函数。

======================继承而来的缺省参数值

=====================

重定义缺省参数值的唯一方法是重定义一个继承而来的函数，而由上面分析可知，重定义继承而来的非虚函数是错误的，因此，我们这里主要讨论“继承一个有缺省参数值的虚函数”。

虚函数是动态绑定的而缺省参数值是静态绑定的。

对象的静态类型是指我们声明的存在于程序代码文本中的类型：

enum ASCEShapeColor{RED,GREEN,BLUE};

class ASCEShape//基类

{

public:

//所有形状都要提供这样一个函数绘制自身

virtual void draw(ASCEShapeColor

color=RED)const=0;

...

};

class ASCERectangle:public ASCEShape

{

public:

//定义了不同的缺省参数值错误！

virtual void draw(ASCEShapeColor color= GREEN)const;

...

};

class ASCECircle:public ASCEShape

{

public:

virtual void draw(ASCEShapeColor color)const;

...

};

ASCEShape*ps;//静态类型是ASCEShape*

ASCEShape*pr=new ASCEShapeRectangle;//静态

类型是ASCEShape*

ASCEShape*pc=new ASCEShapeCircle;//静态类型是ASCEShape*

上面三个指针的静态类型和它们实际所指向的对象的类型是没有关系的。

而对象的动态类型是由它当前所指的对象的类型决定的，即对象的动态类型表示它将执行何种行为。如上面的代码中，pr的动态类型是ASCERectangle*，pc的动态类

型是ASCECircle*，而ps实际上没有动态类型，因为

它还没有指向任何对象。

动态类型可以在程序运行时改变，典型的方法是通过赋值：

ps=pr;//ps的动态类型现在是ASCERectangle*

ps=pc;//ps的动态类型现在是ASCECircle*

虚函数就是动态绑定的，即虚函数通过哪个对象被调用，具体被调用的函数就由那个对象的动态类型决定：

pr->draw(REG);//调用ASCERectangle::draw(REG)

pc->draw(REG);//调用ASCECircle::draw(REG)

虚函数机制的正确性是毋庸置疑的，但当将虚函数和缺省参数值结合起来分析就会产生问题：虚函数是动态绑定的，但缺省参数是静态绑定的，这意味着我们最终可能调用的是一个定义在派生类，但使用了基类中的缺省参数值的虚函数：

pr->draw();//调用的是

ASCERectangle::draw(REG)!!，而不是ASCERectangle::draw(GREEN)

由此，结论就是：禁止重新定义继承而来的缺省参数值！！

main函数的命令行参数

main函数的命令行参数 前面所用到的main函数都是不带参数的，即main()。其实main函数也可以有参数，只是它的参数之一是指针数组。 1．main函数中可以写两个形参，一般形式如下：main(int argc,char *argv[ ]); 2．说明：第一个形参argc是一个整型变量，第二个形参argv是一个指针数组，其元素指向字符型数据。 1 若以下程序所生成的可执行文件名为filel.exe ; 当输入以下命令行执行该程序 时,FILE1 CHINA BEIJING SHANGHAI程序的输出结果是（）。 main( int argc,char *argv[]) { while(argc-->0) { ++argv; printf("%s",*argv);} } A)CHINA BEIJING SHANGHAI B)FILE1 CHINA BEIJING C)C B S D)F C B 2 假定下列程序的可执行文件名为prg.exe，则在该程序的子目录下输入命令行： main(int argc,char *argv[ ]) { int i; if(argc<=0) return; for(i=1;i后程序的输出结果是（）。 A)hello good B)hg C)hel D)hellogood 3 假定以下程序经编译和连接后生成可执行文件PROG.EXE，如果在此可执行文件所在录的DOS提示符下键入：PROG ABCDEFGH IJKL<回车>，则输出结果为（）。 main( int argc, char *argv[])) { while(--argc>0) printf("%s",argv[argc]); printf("\n"); } A) ABCDEFG B) IJHL C) ABCDEFGHIJKL D) IJKLABCDEFGH 4 不合法的main函数命令行参数表示形式是（）。 A) main(int a,char *c[]) B) main(int arc,char **arv) C) main(int argc,char *argv) D) main(int argv,char *argc[]) 5 有以下程序：程序编译连接后生成的可执行文件是exl.exe，若运行时输入带参数的命令行是exl abcd efg 10<回车>则运行的结果是（）。 #include main(int argc,char *argv[]) { int i,len=0; for (i=1; i，则运行结果为（）。 main(int argc, char *argv[]) { int n,i=0; while(argv[1][i]!= '\0') { n=fun(); i++;} printf("%d\n",n*argc); } int fun() { static int s=0; s+=1; return s; } A）6 B）8 C）3 D）4

C语言编程实战-4-命令行参数(main函数)处理

命令行(main函数)参数处理 我们在执行某某命令的时候，经常会传入一些参数，告诉程序做不同的处理。如使用gcc编译程序时，我们经常会在后边指定c源码文件，如gcc test.c。我们自己写的程序，如何能够算其它命令一样，能够接收和处理不同的参数呢？答案是肯定的。我们今天来介绍自写程序对命令行参数的处理。 一个标准的C程序，其主函数通常是这样子定义的： int main(int argc,char *argv[]) { //用户代码 return xxx; } main函数有两个参数：argc与agv，前者是一个整数，表示命令行给程序参数的个数，后者是一个字符串数组，用于顺次存放命令行传给程序的参数，通过argc与argv，我们就能实现对命令行参数的处理。 对每一个程序而言，程序的名称总会作为命令行的第一个参数传给它的主函数，那怕命令行中并没有传任何参数。因此，主函数的参数argc最小值为1，argv[0]总是存放命令程序名。因此，假使test是我们程序的名字，如果执行： test 则main函数得到的参数是：argc = 1, argv = {“test”}; 如果执行： test arg1 arg2 则main函数得到的参数是：argc = 3, argv = {“test”, “arg1”, “arg2”}; 如此类推。 通过上面的讲解，我们不难在main函数中实现对命令行参数的代码。我们接下来做一个编程任务： 写一个程序，该程序接收两个参数，这两个参数都是整数，程序中需将这两个整数的和与差计算并输出到屏幕上。假设程序的名称为cal，在命令行执行： cal 10 15 则程序输出： 10 + 15 = 25 10 – 15 = -5 如果输入的参数不合法，则提示参数错误。 代码实现： #include

主函数main

①主函数main() ②保存单链表函数save() ③重载操作菜单函数load() ④显示单链表内容函数display () ⑤插入元素函数insert () ⑥删除元素函数decelt () ⑦修改元素函数modify() 各函数间关系如下： #include "stdafx.h" #include #include typedef char ElemType; struct LNode { ElemType data; struct LNode *next; }; //***********************************************************置空表setnull() void setnull(struct LNode **p) { *p=NULL; } //************************************************************求长度length() int length(struct LNode **p) { int n=0; struct LNode *q=*p; while (q!=NULL) { n++; q=q->next; }

return(n); } //*************************************************************取结点get() ElemType get(struct LNode **p,int i) { int j=1; struct LNode *q=*p; while (jnext;j++; } if (q!=NULL) /**//*找到了第i个结点*/ return(q->data); else { printf("位置参数不正确!\n"); return NULL; } } //************************************************************按值查找locate() int locate(struct LNode **p,ElemType x) { int n=0; struct LNode *q=*p; while (q!=NULL && q->data!=x) /**//*查找data域为x的第一个结点*/ { q=q->next; n++; } if (q==NULL) /**//*未找到data域等于x的结点*/ return(-1); else /**//*找到data域等于x的结点*/ return(n+1); }

带参数main函数

main函数也可以带参数。带参数main函数的定义格式如下： void main(int argc, char *argv[]) { ... ... } argc和argv是main函数的形式参数。这两个形式参数的类型是系统规定的。如果main函数要带参数，就是这两个类型的参数；否则main函数就没有参数。变量名称argc和argv 是常规的名称，当然也可以换成其他名称。 那么，实际参数是如何传递给main函数的argc和argv的呢？我们知道，C程序在编译和链接后，都生成一个exe文件，执行该exe文件时，可以直接执行；也可以在命令行下带参数执行，命令行执行的形式为： 可执行文件名称参数1 参数2 ... ... 参数n 执行文件名称和参数、参数之间均使用空格隔开。例如，在linux下运行程序./a.out 1 2 ，可执行文件名称为./a.out，参数1为字符串1，参数2为2。 如果按照这种方法执行，命令行字符串将作为实际参数传递给main函数。具体为： (1) 可执行文件名称和所有参数的个数之和传递给argc；所以上面的argc=3 (2) 可执行文件名称（包括路径名称）作为一个字符串，首地址被赋给argv[0]，参数1也作为一个字符串，首地址被赋给argv[1]，... ...依次类推。 本回答专业性由科学教育分类达人陶文认证 满意回答 运行方法： （假设你的程序为Untitled1.exe） 打开命令提示符： 转到你的Untitled1.exe的目录， 输入下列命令： Untitled1.exe a basdfsa 1314324 -k -f 回车就可以运行了。 这时，在Main函数里定义的 int main(int argc, char *args[]) 里的argc = 6,就是表示有六个参数， 对应的 args[0] = "Untitled1.exe"; args[1] = "a"; args[2] = "basdfsa"; args[3] = "1314324"; args[4] = "-k"; args[5] = "-f"; 就是这样子了。

STRING类函数用法总结3

C++中的string类 前言:string的角色 1string使用 1.1充分使用string操作符 1.2眼花缭乱的string find函数 1.3string insert,replace,erase2string和C风格字符串 3string和Charactor Traits 4string建议 5小结 6附录前言:string的角色 C++语言是个十分优秀的语言，但优秀并不表示完美。还是有许多人不愿意使用C或者C++，为什么？原因众多，其中之一就是C/C++的文本处理功能太麻烦，用起来很不方便。以前没有接触过其他语言时，每当别人这么说，我总是不屑一顾，认为他们根本就没有领会C++的精华，或者不太懂C++，现在我接触perl,php,和Shell脚本以后，开始理解了以前为什么有人说C++文本处理不方便了。 举例来说，如果文本格式是：用户名电话号码，文件名name.txt Tom23245332 Jenny22231231 Heny22183942 Tom23245332 ... 现在我们需要对用户名排序，且只输出不同的姓名。 那么在shell编程中，可以这样用： awk'{print$1}'name.txt|sort|uniq 简单吧？ 如果使用C/C++就麻烦了，他需要做以下工作： 先打开文件，检测文件是否打开，如果失败，则退出。 声明一个足够大得二维字符数组或者一个字符指针数组 读入一行到字符空间 然后分析一行的结构，找到空格，存入字符数组中。 关闭文件 写一个排序函数，或者使用写一个比较函数，使用qsort排序 遍历数组，比较是否有相同的，如果有，则要删除，copy... 输出信息 你可以用C++或者C语言去实现这个流程。如果一个人的主要工作就是处理这种

CPPstring类常用函数

C++string类常用函数 string类的构造函数： string(const char *s); //用c字符串s初始化 string(int n,char c); //用n个字符c初始化 此外，string类还支持默认构造函数和复制构造函数，如string s1；string s2="hello"；都是正确的写法。当构造的string太长而无法表达时会抛出length_error异常 string类的字符操作： const char &operator[](int n)const; const char &at(int n)const; char &operator[](int n); char &at(int n); operator[]和at()均返回当前字符串中第n个字符的位置，但at函数提供范围检查，当越界时会抛出out_of_range异常，下标运算符[]不提供检查访问。 const char *data()const;//返回一个非null终止的c字符数组 const char *c_str()const;//返回一个以null终止的c字符串 int copy(char *s, int n, int pos = 0) const;//把当前串中以pos开始的n个字符拷贝到以s为起始位置的字符数组中，返回实际拷贝的数目 string的特性描述: int capacity()const; //返回当前容量（即string中不必增加内存即可存放的元素个数） int max_size()const; //返回string对象中可存放的最大字符串的长度 int size()const; //返回当前字符串的大小 int length()const; //返回当前字符串的长度 bool empty()const; //当前字符串是否为空 void resize(int len,char c);//把字符串当前大小置为len，并用字符c填充不足的部分 string类的输入输出操作: string类重载运算符operator>>用于输入，同样重载运算符operator<<用于输出操作。 函数getline(istream &in,string &s);用于从输入流in中读取字符串到s中，以换行符'\n'分开。 string的赋值： string &operator=(const string &s);//把字符串s赋给当前字符串 string &assign(const char *s);//用c类型字符串s赋值 string &assign(const char *s,int n);//用c字符串s开始的n个字符赋值 string &assign(const string &s);//把字符串s赋给当前字符串 string &assign(int n,char c);//用n个字符c赋值给当前字符串 string &assign(const string &s,int start,int n);//把字符串s中从start开始的n个字符赋给当前字符串 string &assign(const_iterator first,const_itertor last);//把first和last迭代器之间的部

int main参数详解

int main(int argc,char* argv[])详解 argc是命令行总的参数个数 argv[]是argc个参数，其中第0个参数是程序的全名，以后的参数 命令行后面跟的用户输入的参数，比如： int main(int argc, char* argv[]) { int i; for (i = 0; i>i; return 0; } 执行时敲入 F:\MYDOCU~1\TEMPCODE\D1\DEBUG\D1.EXE aaaa bbb ccc ddd 输出如下： F:\MYDOCU~1\TEMPCODE\D1\DEBUG\D1.EXE aaaa bbb ccc ddd -------------------------------------------------------------------- char *argv[]是一个字符数组,其大小是int argc,主要用于命令行参数argv[] 参数，数组里每个元素代表一个参数; 比如你输入 test a.c b.c t.c 则 argc = 4 argv[0] = "test" argv[1] = "a.c" argv[2] = "b.c" argv[3] = "t.c" -------------------------------------------------------------------------------------------- argc记录了用户在运行程序的命令行中输入的参数的个数。 arg[]指向的数组中至少有一个字符指针，即arg[0].他通常指向程序中的可执行文件的文件名。在有些版本的编译器中还包括程序 文件所在的路径。 ------------------------------------------------------------------------- 在调用一个可执行程序时，某些情况下需要向程序传递参数。如我们可以在控制台中键入notepad.exe， 回车后将执行记事本程序。如果我们希望在打开notepad时同时打开一个文本文件，可以在notepad.exe

数组名作为函数参数

杨振平

●数组元素作实参，对应的形参为变量，一次传递一个元素，采用值传递。 ●数组名作实参，对应的形参为一个数组，一次传递整个数组。 ●数组作参数，其参数传递可理解为形参数组与实参数组共用同一数组空间（即共用实参数组空间）。因此，在函数中，使用形参数组就是在使用实参数组，改变形参数组元素的值就是在改变实参数组元素的值，这一点与引用传递非常相似。

1.一维数组的传递 ?一维数组作形参的声明格式： <类型> <数组名>[] 其中，[]中可以省略数组的长度值。（可认为形参数组与实参数组长度相同） ?对应的实参应为同类型的一维数组名。（仅用数组名） 说明：为了使函数知道需要处理的数组元素的个数，通常给函数再传递一个表示元素个数的整型数。

数组名作为函数参数（续） 例如：一维数组名作为函数的参数。编写函数，计算一个整型数组中从第m个元素（m从0开始）开始的n个元素之和。函数设计： 函数原型：int fun(int b[],int m,int n); 功能：计算数组b中从第m个元素开始的n个元素之和。 主函数设计： 定义并初始化一个整型数组a。 测试1：fun(a,0,10);//求从第0个元素开始的10个元素之和 测试2：fun(a,3,5); //求从第3个元素开始的5个元素之和

int fun(int b[],int m,int n) { int i,s=0; for(i=m;i

string类中函数介绍

标准c++中string类函数介绍 注意不是CString 之所以抛弃char*的字符串而选用C++标准程序库中的string类，是因为他和前者比较起来，不必担心内存是否足够、字符串长度等等，而且作为一个类出现，他集成的操作函数足以完成我们大多数情况下(甚至是100%)的需要。我们可以用= 进行赋值操作，== 进行比较，+ 做串联（是不是很简单?）。我们尽可以把它看成是C++的基本数据类型。 好了，进入正题……… 首先，为了在我们的程序中使用string类型，我们必须包含头文件。 如下： #include //注意这里不是string.h string.h是C字符串头文件 #include using namespace std; 1．声明一个C++字符串 声明一个字符串变量很简单： string Str; 这样我们就声明了一个字符串变量，但既然是一个类，就有构造函数和析构函数。上面的声明没有传入参数，所以就直接使用了string的默认的构造函数，这个函数所作的就是把Str 初始化为一个空字符串。String类的构造函数和析构函数如下： a) string s; //生成一个空字符串s b) string s(str) //拷贝构造函数生成str的复制品 c) string s(str,stridx) //将字符串str内“始于位置stridx”的部分当作字符串的初值 d) string s(str,stridx,strlen) //将字符串str内“始于stridx且长度顶多strlen”的部分作为字符串的初值 e) string s(cstr) //将C字符串作为s的初值 f) string s(chars,chars_len) //将C字符串前chars_len个字符作为字符串s的初值。 g) string s(num,c) //生成一个字符串，包含num个c字符 h) string s(beg,end) //以区间beg;end(不包含end)内的字符作为字符串s的初值 i) s.~string() //销毁所有字符，释放内存 都很简单，我就不解释了。 2．字符串操作函数 这里是C++字符串的重点，我先把各种操作函数罗列出来，不喜欢把所有函数都看完的人可以在这里找自己喜欢的函数，再到后面看他的详细解释。 a) =,assign() //赋以新值 b) swap() //交换两个字符串的内容 c) +=,append(),push_back() //在尾部添加字符

关于main函数的(int argc,char argv[])

main(int argc,char *argv[ ]) argv为指针的指针 argc为整数 char **argv or: char *argv[] or: char argv[][] main()括号内是固定的写法。 下面给出一个例子来理解这两个参数的用法： 假设程序的名称为prog， 当只输入prog，则由操作系统传来的参数为： argc=1,表示只有一程序名称。 argc只有一个元素，argv[0]指向输入的程序路径及名称：./prog 当输入prog para_1，有一个参数，则由操作系统传来的参数为： argc=2，表示除了程序名外还有一个参数。 argv[0]指向输入的程序路径及名称。 argv[1]指向参数para_1字符串。 当输入prog para_1 para_2 有2个参数，则由操作系统传来的参数为： argc=3，表示除了程序名外还有2个参数。 argv[0]指向输入的程序路径及名称。 argv[1]指向参数para_1字符串。 argv[2]指向参数para_2字符串。 void main( int argc, char *argv[] ) char *argv[] : argv 是一个指针数组，他的元素个数是argc，存放的是指向每一个参数的指针， 他的第一个元素即argv[0]为编译生成的可执行文件名(包括路径eg:"F:\VC\Ex1\Debug\Ex1.exe")，从二个元素(argv[1])开始，是每一个参数int argc 表示argv的大小，是实际参数个数＋1，其中＋1是因为argv[0]是编译后的可执行文件名main()主函数 每一C 程序都必须有一main()函数, 可以根据自己的爱好把它放在程序的某个地方。有些程序员把它放在最前面, 而另一些程序员把它放在最后面, 无论放 在哪个地方, 以下几点说明都是适合的。 1. main() 参数 在Turbo C2.0启动过程中, 传递main()函数三个参数: argc, argv和env。 * argc: 整数, 为传给main()的命令行参数个数。 * argv: 字符串数组。 在DOS 3.X 版本中, argv[0] 为程序运行的全路径名; 对DOS 3.0 以下的版本, argv[0]为空串("") 。 argv[1] 为在DOS命令行中执行程序名后的第一个字符串; argv[2] 为执行程序名后的第二个字符串; ... argv[argc]为NULL。 *env: 安符串数组。env[] 的每一个元素都包含ENVV AR=value形式的字符串。其中ENVV AR为环境变量如PA TH或87。value 为ENVV AR的对应值如C:\DOS, C: \TURBOC(对于PA TH) 或YES(对于87)。 Turbo C2.0启动时总是把这三个参数传递给main()函数, 可以在用户程序中说明(或不说明)它们, 如果说明了部分(或全部)参数, 它们就成为main()子程序的局部变量。

C++string类标准库常用函数

C++ string类标准库常用函数 [string类的构造函数] string(const char *s); //用c字符串s初始化 string(int n,char c); //用n个字符c初始化 [string类的字符操作] const char &operator[](int n) const; const char &at(int n) const; char &operator[](int n); char &at(int n); operator[]和at()均返回当前字符串中第n个字符的位置，但at函数提供范围检查，当越界时会抛出out_of_range 异常，下标运算符[]不提供检查访问。 const char *data() const; //返回一个非null终止的c字符数组 const char *c_str() const; //返回一个以null终止的c字符串 int copy(char *s, int n, int pos = 0) const;//把当前串中以pos开始的n个字符拷贝到以s为起始位置的字符数组中，返回实际拷贝的数目 [string的特性描述] int capacity() const; //返回当前容量（即string中不必增加内存即可存放的元素个数） int max_size() const; //返回string对象中可存放的最大字符串的长度 int size() const; //返回当前字符串的大小 int length() const; //返回当前字符串的长度 bool empty() const; //当前字符串是否为空 void resize(int len,char c); //把字符串当前大小置为len，并用字符c填充不足的部分 [string类的输入输出操作] string类重载运算符operator>>用于输入，同样重载运算符operator<<用于输出操作。 函数getline(istream &in,string &s);用于从输入流in中读取字符串到s中，以换行符'\n'分开。 [string的赋值] string &operator=(const string &s); //把字符串s赋给当前字符串 string &assign(const char *s); //用c类型字符串s赋值 string &assign(const char *s,int n); //用c字符串s开始的n个字符赋值 string &assign(const string &s); //把字符串s赋给当前字符串 string &assign(int n,char c); //用n个字符c赋值给当前字符串 string &assign(const string &s,int start,int n);//把s中从start开始的n个字符赋给当前字符串string &assign(const_iterator first,const_iterator last);//把迭代器first和last之间的部分赋给字符串 [string的连接] string &operator+=(const string &s); //把字符串s连接到当前字符串的结尾 string &append(const char *s); //把c类型字符串s连接到当前字符串结尾 string &append(const char *s,int n); //把c类型字符串s的前n个字符连接到当前字符串结尾 string &append(const string &s); //同operator+=() string &append(const string &s,int pos,int n); //把字符串s中从pos开始的n个字符连接到当前字符串的结尾 string &append(int n,char c); //在当前字符串结尾添加n个字符c string &append(const_iterator first,const_iterator last); //把迭代器first和last之间的部分连接到当前字符串的结尾

c c++ main 函数命令行参数的使用 知识小结

c/c++ main 函数命令行参数的使用知识小结 2012-12-31 13:13:43 我来说两句作者：wu_lai_314 收藏我要投稿C程序最大的特点就是所有的程序都是用函数来装配的。main()称之为主函数，是所有程 序运行的入口。其余函数分为有参或无参两种，均由main()函数或其它一般函数调用，若调用 的是有参函数，则参数在调用时传递。 C/C++语言中的main函数，经常带有参数argc，argv，如下： int main(int argc, char** argv)int main(int argc, char* argv[])从函数参数的形式上看，包含一个整型和一个指针数组。当一个C/C++的源程序经过编译、链接后，会生成扩展名为.EXE的可执行文件，这是可以在操作系统下直接运行的文件，换句话说，就是由系统来启动运行的。对main()函数既然不能由其它函数调用和传递参数，就只能由 系统在启动运行时传递参数了。 在操作系统环境下，一条完整的运行命令应包括两部分：命令与相应的参数。其格式为： 命令参数1参数2....参数n? 此格式也称为命令行。命令行中的命令就是可执行文件的文件名，其后所跟参数需用空格分隔，并为对命令的进一步补充，也即是传递给main()函数的参数。 命令行与main()函数的参数存在如下的关系： 设命令行为：program str1 str2 str3 str4 str5 其中program为文件名，也就是一个由program.c经编译、链接后生成的可执行文件program.exe，其后各跟5个参数。对main()函数来说，它的参数argc记录了命令行中命令与参数的个数，共6个，指针数组的大小由参数argc的值决定，即为char*argv[6]，指针数组的取值情况如图6-15所示。

Main函数参数argc,argv说明

Main函数参数argc，argv说明 C/C++语言中的main 函数，经常带有参数argc，argv，如下：int main(int argc, char** argv) int main(int argc, char* argv[]) 这两个参数的作用是什么呢？argc 是指命令行输入参数的个数，argv 存储了 所有的命令行参数。假如你的程序是hello.exe，如果在命令行运行该程序，（首 先应该在命令行下用cd 命令进入到hello.exe 文件所在目录）运行命令为：hello.exe Shiqi Yu 那么，argc 的值是3，argv[0]是”hello.exe”，argv[1]是”Shiqi”，argv[2]是”Yu”。 下面的程序演示argc 和argv 的使用： #include int main(int argc, char ** argv) { int i; for (i=0; i 假如上述代码编译 为hello.exe，那么运行 hello.exe a b c d e 将得到 Argument 0 is hello.exe. Argument 1 is a. Argument 2 is b. Argument 3 is c. Argument 4 is d. Argument 5 is e.运行 hello.exe lena.jpg 将得到 Argument 0 is hello.exe. Argument 1 is lena.jpg.================================#include #include #include int main(int argc ,char * argv[]){int i;char arg[6][15]={0};printf(“argc: %d /n”,argc);for(i=0;i{sprintf(arg[i],”%s” ,argv[i]);}//for(i=1;i//printf(“%s/n”,arg[i]);execlp(“/bin/mkdir”,”mkdir”,arg[1],NULL); return 1;}======================================清单 2. BusyBox 使 用argv[0] 来确定调用哪个应用程序// test.c #include int main( int argc, char

C 中的string常用函数用法总结.

C++中的string常用函数用法总结首先，为了在我们的程序中使用string类型，我们必须包含头文件。 如下： #include //注意这里不是string.h string.h是C字符串头文件 #include using namespace std; 1．声明一个C++字符串 声明一个字符串变量很简单： string Str; 这样我们就声明了一个字符串变量，但既然是一个类，就有构造函数和析构函数。上面的声明没有传入参数，所以就直接使用了string的默认的构造函数，这个函数所作的就是把Str 初始化为一个空字符串。String类的构造函数和析构函数如下： a) string s; //生成一个空字符串s b) string s(str) //拷贝构造函数生成str的复制品 c) string s(str,stridx) //将字符串str内“始于位置stridx”的部分当作字符串的初值 d) string s(str,stridx,strlen) //将字符串str内“始于stridx且长度顶多st rlen”的部分作为字符串的初值 e) string s(cstr) //将C字符串作为s的初值 f) string s(chars,chars_len) //将C字符串前chars_len个字符作为字符串s的初值。 g) string s(num,c) //生成一个字符串，包含num个c字符 h) string s(beg,end) //以区间beg;end(不包含end)内的字符作为字符串s的初值 i) s.~string() //销毁所有字符，释放内存 都很简单，我就不解释了。

C语言主函数main的注意

# include main() { int i=50; while(i<=80) { szd-h: i += 10; if(i==80) goto szd-h cout<<"i is"<就行 第二，main 函数应该带上一个返回值int,这是出于兼容性的考虑，在前面的帖子中，有位兄弟找到了这样的一段话： 在 C 和C++ 中，不接收任何参数也不返回任何信息的函数原型为“void foo(void);”。可能正是因为这个，所以很多人都误认为如果不需要程序返回任何信息时可以把main 函数定义成void main(void) 。然而这是错误的！main 函数的返回值应该定义为int 类型，C 和C++ 标准中都是这样规定的。虽然在一些编译器中，void main 可以通过编译（如vc6），但并非所有编译器都支持void main ，因为标准中从来没有定义过void main 。g++3.2 中如果main 函数的返回值不是int 类型，就根本通不过编译。而gcc3.2 则会发出警告。所以，如果你想你的程序拥有很好的可移植性，请一定要用int main 。 有int main()后，就要加上return 0;当然，你不显示的写int 也就是说默认为int型，也要加上return 0；否则会有warning出现！ 第三，标示符写错了，可能是作者的粗心所至，sxd_h，最好还是不要用这样的标示符，感觉没有什么可读性```` 第四，goto szd_h;后面要分号！ 我稍微修改了一下，但是程序结构一点没变 # include using namespace std; int main() { int i=50; while(i<=80) { szd_h: i += 10; if(i==80)

String常见的操作和方法

String常见的操作和方法 String类适用于描述字符串事物 那么它就提供了多个方法对字符串进行操作。 常见的操作有哪些？ “afbs” 1、获取 1.1 字符串中包含的字符数，也就是字符串的长度。 int length(): 获取长度。 1.2 根据位置获取位置上某个字符。 char charAt(int index): 1.3 根据字符获取字符在字符串中位置。 int indexOf(int ch): 返回的是ch在字符串中第一次出现的位置。 int indexOf(int ch, int fromIndex): 从fromIndex指定位置开始，获取ch在字符串中出现的位置。 int indexOf(int str): 返回的是str在字符串中第一次出现的位置。 int indexOf(int str, int fromIndex): 从fromIndex指定位置开始，获取str在字符串中出现的位置。 int lastIndexOf(int ch); 2、判断。 2.1 字符串中是否包含某一个子串。 boolean contains(str): 特殊之处：indexOf(str):可以索引str第一次出现的位置，如果返回-1.表示该str不存在字符串中。 所以，也可以用于对指定判断是否包含。 if(str.indexOf("aa")!=-1) 而且该方法既可以判断，又可以获取出现的位置。 2.2 字符串中是否有内容。

boolean ifEmpty(): 原理就是判断长度是否为0. 2.3 字符串是否是以指定内容开头。 boolean startsWith(str); 2.4 字符串是否是以指定内容结尾。 boolean endsWith(str); 2.5判断字符串内容是否相同。复写了Object类中的equals方法。boolean equals(str); 2.6判断内容是否相同，并忽略大小写。 boolean equalsIgnoreCase(); 3、转换 3.1 将字符数组转成字符串。 构造函数：String(char[]) String(char[],offset,count):将字符数组中的一部分转成字符串。 静态方法： static String copyValueOf(char[]); static String copyValueOf(char[] data,int offset,int count) static String valueOf(char[]): 3.2 将字符串转成字符数组。 char[] toCharArray(): 3.3 将字节数组转成字符串。 String(byte[]) String(byte[],offset,count):将字节数组中的一部分转成字符串。 3.4 将字符串转成字节数组。** byte[] getBytes(): 3.5 将基本数据类型转成字符串。 static String valueOf(int) static String valueOf(double) 3+"";//String.valueOf(3); 特殊：字符串和字节数组在转换过程中，是可以指定编码表的。

main函数的参数

一、ｍａｉｎ函数的参数 我们经常用的main函数都是不带参数的。因此main 后的括号都是空括号。实际上，main函数可以带参数，这个参数可以认为是main函数的形式参数。Ｃ语言规定main函数的参数只能有两个，习惯上这两个参数写为argc和argv。因此，main函数的函数头可写为：main (argc,argv)Ｃ语言还规定argc(第一个形参)必须是整型变量,argv( 第二个形参)必须是指向字符串的指针数组。加上形参说明后，main函数的函数头应写为： main (argc,argv) int argv; char *argv[];或写成： main (int argc,char *argv[]) 由于main函数不能被其它函数调用，因此不可能在程序内部取得实际值。那么，在何处把实参值赋予main函数的形参呢? 实际上,main函数的参数值是从操作系统命令行上获得的。当我们要运行一个可执行文件时，在DOS提示符下键入文件名，再输入实际参数即可把这些实参传送到main的形参中去。 DOS提示符下命令行的一般形式为：C:\>可执行文件名参数参数……; 但是应该特别注意的是，main 的两个形参和命令行中的参数在 位置上不是一一对应的。因为,main的形参只有二个，而命令行中的参数个数原则上未加限制。argc参数表示了命令行中参数的个数(注意：文件名本身也算一个参数)，argc的值是在输入命令行时由系统按实际参数的个数自动赋予的。例如有命令行为：C:\>E6 24 BASIC dbase FORTRAN由于文件名E6 24本身也算一个参数，所以共有4个参数，因此argc取得的值为4。argv参数是字符串指针数组，其各元素值为命令行中各字符串(参数均按字符串处理)的首地址。指针数组的长度即为参数个数。数组元素初值由系统自动赋予。其表示如图6.8所示：main(int argc,char *argv){ while(argc-->1) printf("%s\n",*++argv); } 本例是显示命令行中输入的参数如果上例的可执行文件名为e24.exe，存放在A 驱动器的盘内。 因此输入的命令行为：C:\>a:e24 BASIC dBASE FORTRAN 则运行结果为： BASIC dBASE FORTRAN 该行共有4个参数，执行main时，argc的初值即为4。argv的4个元素分为4个字符串的首地址。执行while语句，每循环一次argv值减1，当argv等于1时停止循环，共循环三次，因此共可输出三个参数。在printf函数中，由于打印项*++argv是先加1再打印，故第一次打印的是argv[1]所指的字符串BASIC。第二、三次循环分别打印后二个字符串。而参数e24是文件名，不必输出。