//设置默认值参数
＃i nclude <iostream>
＃i nclude <string>
using namespace std;
void OutputInfo(const char* pchData="One world, one dream!") //默认值
{
cout<<pchData<<endl;
}
void main()
{
OutputInfo(); //按默认值执行
OutputInfo("Beijing 2008 Olympic Games!"); //按新值执行
}
=========
//非法默认参数值
＃i nclude <iostream>
＃i nclude <string>
using namespace std;
int GetMax(int x,int y=10,int z) //后两个必须有值才行，不能中间有值而后无
{
if(x<y)
x=y;
if(x<z)
x=z;
return x;
}
void main()
{
int m=GetMax();
cout<<m<<endl;
}
========
//非法默认参数值
＃i nclude <iostream>
＃i nclude <string>
using namespace std;
int GetMax(int x=3,int y=10,int z=5)
{
if(x<y)
x=y;
if(x<z)
x=z;
return x;
}
void main()
{
int m=GetMax(); //都有默认值才能这样空参调用，否则会提示缺参
cout<<m<<endl;
}
==========
//数组冒泡
＃i nclude <iostream>
＃i nclude <string>
using namespace std;
void Sort(int array[10]) //定义一个排序函数
{
int itemp = 0; //定义一个临时变量
for(int i=0; i<10; i++) //利用冒泡法排序
{
for(int j=0; j<10-i;j++)
{
if (array[j]>array[j+1]) //交换数组元素
{
itemp = array[j];
array[j] = array[j+1];
array[j+1] = itemp;
}
}
}
cout<<"排序之后：";
for(i=0; i<10; i++) //输出排序后的结果
{
cout<<array[i]<<",";
}
}
int main(int argc, char* argv[])
{
int iarray[10] = {10,9,8,7,6,5,4,3,2,1}; //定义提个整型数组
cout<<"原始数据："; //输出原始数据
for(int i=0; i<10; i++)
{
cout<<iarray[i]<<",";
}
cout<<endl; //输出换行
Sort(iarray); //对数组元素进行排序
cout<<endl;
return 0;
}
==========
//如果定义的是变长数组
// ArrayArgument.cpp : Defines the entry point for the console application.
//
＃i nclude <iostream>
＃i nclude <string>
using namespace std;
void Sort(int array[],int len) //定义一个排序函数
{
int itemp = 0; //定义一个临时变量
for(int i=0; i<len; i++) //利用冒泡法排序 len是变长
{
for(int j=0; j<len-i;j++)
{
if (array[j]>array[j+1]) //交换数组元素
{
itemp = array[j];
array[j] = array[j+1];
array[j+1] = itemp;
}
}
}
cout<<"排序之后：";
for(i=0; i<len; i++) //输出排序后的结果
{
cout<<array[i]<<",";
}
}
int main(int argc, char* argv[])
{
int iarray[] = {10,9,8,7,6,5,4,3,2}; //定义提个整型数组
int len=sizeof(iarray)/sizeof(int); //获取数组长度,注意除整型长
cout<<len;
if (len<10)
{
cout<<"原始数据："; //输出原始数据
for(int i=0; i<len; i++)
{
cout<<iarray[i]<<",";
}
cout<<endl; //输出换行
Sort(iarray,len); //对数组元素进行排序
cout<<endl;
return 0;
}
=========
//如果输入数组小于10,如何暂停并退出
＃i nclude <iostream>
＃i nclude <string>
using namespace std;
void Sort(int array[],int len) //定义一个排序函数
{
int itemp = 0; //定义一个临时变量
for(int i=0; i<len; i++) //利用冒泡法排序
{
for(int j=0; j<len-i;j++)
{
if (array[j]>array[j+1]) //交换数组元素
{
itemp = array[j];
array[j] = array[j+1];
array[j+1] = itemp;
}
}
}
cout<<"排序之后：";
for(i=0; i<len; i++) //输出排序后的结果
{
cout<<array[i]<<",";
}
}
int main(int argc, char* argv[])
{
int iarray[] = {10,9,8,7,6,5,4,3,2,1}; //定义提个整型数组
int len=sizeof(iarray)/sizeof(int);
if (len<10)
{
cout<<"len的值为"<<len<<endl;
cout<<"len的值小于10"<<endl;
system("pause"); //暂停程序
exit(1); //退出
}
cout<<"原始数据："; //输出原始数据
for(int i=0; i<len; i++)
{
cout<<iarray[i]<<",";
}
cout<<endl; //输出换行
Sort(iarray,len); //对数组元素进行排序
cout<<endl;
return 0;
}
==========
// 按值传参
＃i nclude <iostream>
＃i nclude <string>
using namespace std;
void ValuePass(int var) //定义指针类型参数
{
var=10;
cout<<var<<endl;
}
void main()
{
int ivar=5;
ValuePass(ivar);
cout<<ivar<<endl;
}
=======
// 按引用传参
＃i nclude <iostream>
＃i nclude <string>
using namespace std;
void ValuePass(int *var) //定义指针类型参数
{
*var=10;
cout<<*var<<endl;
}
void main()
{
int ivar=5;
ValuePass(&ivar);
cout<<ivar<<endl;
}
============
// 按引用类型作为函数参数 传引用和函数引用效果是相同的.
//对于引用类型,引用必须被初始化为一个对象,并助不能使它再指向其他对象.因为对引用赋值实际上是对目标对象赋值.优点是在函数中不用验证引用参数的合法性.使用指针对象作函数参数,用户可以随意修改参数指向的对象,这是引用类型做不到的.
＃i nclude <iostream>
＃i nclude <string>
using namespace std;
void ValuePass(int &var) //定义指针类型参数
{
var=10;
cout<<var<<endl;
}
void main()
{
int ivar=5;
ValuePass(ivar);
cout<<ivar<<endl;
}
=========
// 按引用类型作为函数参数
＃i nclude <iostream>
＃i nclude <string>
using namespace std;
void ValuePass(int &var) //定义指针类型参数
{
var=10;
cout<<var<<endl;
}
void main()
{
ValuePass(0); //错误,这里0被认为是空指针,他的取地址会出错
cout<<ivar<<endl;
}
=======
// 省略号参数,代表函数的参数多少是不固定的.
＃i nclude <iostream>
＃i nclude <string>
＃i nclude <stdarg.h> //要引用这个
using namespace std;
void OutputInfo(int num,...)
{
va_list arguments; //定义var_list类型变量
va_start(arguments,num) ;
while(num--) //读取所有参数的数据 有2个
{
char* pchData = va_arg(arguments,char*); //获取字符串参数
int iData = va_arg(arguments,int); //获取整型参数
cout<<pchData<<endl; //输出
cout<<iData<<endl;
}
va_end(arguments);
}
int main()
{
OutputInfo(2,"Beijing",2008,"Olympic Games",2008);
return 0;
}
======
可变参数列表：
在函数原型中，列出了函数期望接受的参数，但原型只能显示固定数目的参数，如何让一个函数在不同的时候接受不同数目的参数呢？
stdarg宏：
可变参数列表时通过宏来实现的，这些宏定义在stdarg.h头文件中，他是标准库的一部分。这个头文件声明了一个类型va_list和三个宏 ——va_start、va_arg和va_end。
函数声明可以声明一个va_list类型的变量，变量名为 var_arg。通过调用va_start()来初始化，它的第1个参数是va_list变量名字，第2个参数是省略号前最后一个有名字的参数。
为了访问参数，需要使用va_arg()，这个宏接受两个参数：va_list变量和参数列表中下一个参数的类型。
最后，当访问完最后一个可变参数后，我们需要调用va_end()。
注：可变参数列表，仅支持可变参数的顺序访问。如果在顺序访问几个参数后中途终止是可以的，但是不能跳跃式的访问可变参数。
=========
//函数的重载
＃i nclude <iostream>
＃i nclude <string>
using namespace std;
int Add(int x,int y)
{
cout<<"整型"<<endl;
return x+y;
}
double Add(double x,double y)
{
cout<<"实数"<<endl;
return x+y;
}
float Add(float x,float y)
{
cout<<"浮点"<<endl;
return x+y;
}
int main()
{
int ivar = Add(5,2);
float fvar1 = Add(10.5,11.4);
float fvar2 = Add(10.5f,11.4f);
return 0;
}
-=========
//使用函数指针,可以灵活定义通用函数,函数名指向函数的长指针,也可以自定义类型
＃i nclude <iostream>
＃i nclude <string>
using namespace std;
//使用函数指针指向不同的函数
//通用函数,实现两个数的加\减\乘\除等操作
typedef int (*ptfun)(int,int); //定义函数指针
int invoke(int x,int y,ptfun fun) //定义通用功能函数
{
return fun(x,y);
}
int sum(int x,int y)
{
return x+y;
}
int sub(int x,int y)
{
return x-y;
}
int mul(int x,int y)
{
return x*y;
}
int divi(int x,int y)
{
return x/y;
}
int main()
{
ptfun pfun; //定义函数指针变量
pfun=sum;
int ret=invoke(20,10,pfun);
cout<<ret<<endl;
pfun=mul;
ret=invoke(20,10,pfun);
cout<<ret<<endl;
return 0;
}
