ES6中给出了函数的默认值设置，下面简单介绍几种设置默认参数的方法

一.基本用法
function first(x = 1, y = 2) {
    console.log("x："+x ,"y："+ y);
}
first();
first(100);


二.与解构赋值默认值结合
function second({x, y = 2}) {
    console.log("x："+x ,"y："+ y);
}
second({});
second({x:100});
second({x:100,y:200});

这种写法在传入多个形参时可以不按顺序写入，会方便很多，可是会有个问题，没有默认值时，每次都要传“{}”就会显得很麻烦，于是我们可以再设置一次默认值

三.双重默认值
function third({x = 1 ,y = 2} = {}) {
    console.log("x："+x ,"y："+ y);
}
third();
third({x:100,y:200});
third({x:100});

这种写法就不会出现易错的情况啦


四.总结
以后再进行封装函数时应改用默认值设置，特别是某些多参数的函数

先说说函数定义，我们都知道，下面的代码定义了一个函数funcA

def funcA():

  pass

    

显然，函数funcA没有参数（同时啥也不干:D）。

下面这个函数funcB就有两个参数了，

def funcB(a, b):

  print a

  print b

调用的时候，我们需要使用函数名，加上圆括号扩起来的参数列表，比如 funcB(100, 99)，执行结果是：

100

99

很明显，参数的顺序和个数要和函数定义中一致，如果执行funcB(100)，Python会报错的：

TypeError: funcB() takes exactly 2 arguments (1 given)

我们可以在函数定义中使用参数默认值，比如

def funcC(a, b=0):

  print a

  print b

在函数funcC的定义中，参数b有默认值，是一个可选参数，如果我们调用funcC(100)，b会自动赋值为0。

我们要定义一个函数的时候，必须要预先定义这个函数需要多少个参数（或者说可以接受多少个参数）。一般情况下这是没问题的，但是也有在定义函数的时候，不能知道参数个数的情况（想一想C语言里的printf函数），在Python里，带*的参数就是用来接受可变数量参数的。看一个例子
def funcD(a, b, *c):
  print a
  print b
  print "length of c is: %d " % len(c)
  print c
调用funcD(1, 2, 3, 4, 5, 6)结果是
1
2
length of c is: 4
(3, 4, 5, 6)
我们看到，前面两个参数被a、b接受了，剩下的4个参数，全部被c接受了，c在这里是一个tuple。我们在调用funcD的时候，至少要传递2个参数，2个以上的参数，都放到c里了，如果只有两个参数，那么c就是一个empty tuple。

好了，一颗星我们弄清楚了，下面轮到两颗星。

上面的例子里，调用函数的时候，传递的参数都是根据位置来跟函数定义里的参数表匹配的，比如funcB(100, 99)和funcB(99, 100)的执行结果是不一样的。在Python里，还支持一种用关键字参数(keyword argument)调用函数的办法，也就是在调用函数的时候，明确指定参数值付给那个形参。比如还是上面的funcB(a, b)，我们通过这两种方式调用

funcB(a=100, b=99)

和

funcB(b=99, a=100)

结果跟funcB(100, 99)都是一样的，因为我们在使用关键字参数调用的时候，指定了把100赋值给a，99赋值给b。也就是说，关键字参数可以让我们在调用函数的时候打乱参数传递的顺序！

另外，在函数调用中，可以混合使用基于位置匹配的参数和关键字参数，前题是先给出固定位置的参数，比如

def funcE(a, b, c):

  print a

  print b

  print c

调用funcE(100, 99, 98)和调用funcE(100, c=98, b=99)的结果是一样的。

好了，经过以上铺垫，两颗星总算可以出场了：
如果一个函数定义中的最后一个形参有 ** （双星号）前缀,所有正常形参之外的其他的关键字参数都将被放置在一个字典中传递给函数，比如：
def funcF(a, **b):
  print a
  for x in b:
    print x + ": " + str(b[x])
调用funcF(100, c='你好', b=200)，执行结果
100
c: 你好
b: 200
大家可以看到，b是一个dict对象实例，它接受了关键字参数b和c。

常规参数，*参数及**参数可以同时使用，具体怎么用？看看Python Reference Manual吧，关于Function definitions的那些章节。其实，笨想也能猜出来啊，o(∩_∩)o...

概括:c程序在运行的时候，main中有两个参数，分别是int argc 和后面的 char * argv[],前面的不用输入，会自动统计你后面所输入的字符串的数量（空格区分）,argv[0]保存的是文件路径和名字，所有argc>=1;


原文转自：http://blog.csdn.net/wu_lai_314/article/details/8454394




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所示。











数组的各指针分别指向一个字符串。应当引起注意的是接收到的指针数组的各指针是从命令行的开始接收的，首先接收到的是命令，其后
才是参数。





下面的程序演示argc和argv的使用：









[cpp] view
 plain copy





#include<iostream>  

  

using namespace std;  

  

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

  

    for(int i=0;i<argc;i++)  

        cout<<"Argument "<<i<<" is "<<argv[i]<<endl;  

    return EXIT_SUCCESS;  

}  

该程序编译运行成功，产生了 test.exe 文件，在打开DOS窗口，用cd命令进入到 test.exe 文件夹下 ，在DOS下输入如下命令：



test.exe
 hello! this is a test!

则运行的结果如下：

构造函数、析构函数是怎么回事呢
构造函数和析构函数什么时候执行，怎么执行
因为类的数据成员不能在类声明的时候初始化，所以需要构造函数来实现某些成员函数的初始化。下面定义的变量需要通过构造函数Line中的参数进行初始化，当用Line创建一个类对象时自动执行。
class Line
{
   public:
      Line(double len);   // 这是构造函数声明
      void getLength();
      ~Line();  // 这是析构函数声明
   private:
      double length;
};

构造函数名称和类名相同，析构函数的名称为“~类名”。
成员函数定义：
Line::Line(double len)//构造函数定义
{
    length=len;
    cout << "Object is being created" << endl;
}
Line::~Line()//析构函数定义
{
    cout << "Object is being deleted" << endl;
}
void Line::getLength()
{
    cout<<"the length of the line is"<<length<<endl;
}

在创建类的对象时，自动执行构造函数，并对类中的变量传参，进行初始化。在主函数return 0时，自动执行析构函数。
int main( )
{
   int i=0;cout<<i<<endl;  //cout<<i<<endl，用这一句代码来看构造函数和析构函数什么时候运行
   Line line(10.9);i++;cout<<i<<endl;
   line.getLength();//此时并未执行析构函数，从运行结果可以看出↓
   i++;cout<<i<<endl;
   return 0;
}

执行结果是
0                                                                                                                       
Object is being created                                                                                                 
1                                                                                                                       
the length of the line is10.9                                                                                           
2                                                                                                               
Object is being deleted

可以看出， 当运行Line line;时，构造函数自动执行；而直到return 0；析构函数才自动执行。
带参数的构造函数和不带参数的构造函数
构造函数可以是带参数的，也可以是不带参数的，都可以实现类中变量的初始化，给大家看一下区别
class Student{
private:
    char *m_name;
    int m_age;
    float m_score;
public:
    Student();//这是不带参数的构造函数
    Student(char *name, int age, float score);//这是带了三个不同类型参数的构造函数
    void show();
};
Student::Student(){    //这是不带参数的构造函数的变量初始化过程；
    m_name = NULL;
    m_age = 0;
    m_score = 0.0;
}
Student::Student(char *name, int age, float score){        //这是带参数的构造函数的变量初始化过程；
    m_name = name;
    m_age = age;
    m_score = score;
}
void Student::show(){
    if(m_name == NULL || m_age <= 0){ cout<<"成员变量还未初始化"<<endl; }
    else{cout<<m_name<<"的年龄是"<<m_age<<"，成绩是"<<m_score<<endl;  }
}
int main(){
//调用构造函数 Student()
    Student stud;//创建一个不带参数的对象
    stud.show();
    Student stu("小明", 15, 92.5f);//创建一个带参数的对象
    stu.show();
    return 0;
}

以上代码的运行结果是
成员变量还未初始化                                                                                                      
小明的年龄是15，成绩是92.5

通过以上程序段可以看出，如果创建一个不带参数的类对象，会自动执行不带参数的构造函数，如果程序员没有定义构造函数，则系统有一个默认构造函数可以执行。创建一个带有参数的类对象，则自动执行参数数量和类型相匹配的构造函数。