参考自d程序设计语言---我的博客http://my.oschina.net/u/218155/blog?fromerr=SwOkb7Sw fllow me
d语言的函数非常丰富。我也只学了一点皮毛,希望能和大家共同探讨。
最基本的函数和java,c,c++类似哦,是不是。
bool greater(int a, int b)
{
return a < b;
}
对可变数组的单个值操作会改变可变数组的值
对整个可变数组赋值不会改变值
//change data
void func(int x){ x++;}
void gunc(int[] x) {x=[1,2,3];}
void sunc(int[] x){x[0] = x[1];}
auto x = [1,2];
assert(gunc(x) == [1,2]);
assert(sunc(x) == [2,2]);
d语言的查找的基本方法
//find data like list
bool findData(int[] need,int val){
foreach(v;need){
if(v == val) return true;
}
return false;
}
//find data in array
int[] findList(int[] need, int val){
while(need.length > 0 && need[0] != val){
need = need[1..$];
}
return need;
}
auto mylist = [1,2,3,4,5];
assert(findData(mylist,2) == true);
assert(findList(mylist,2).length == 4);
mylist = [];
assert(findList(mylist,2) == []);
dlang支持通过在参数前增加ref改变参数的值,这个是后传递的是参数的地址哦。
void func_ref(ref int x){x++;}
ref int func_ref_ref(ref int x){x++; return x;}
int x = 0;
func_ref(x);
assert(x == 2);
assert(func_ref_ref(func_ref_ref(x)) == 4);
dlang可以在参数前加in让参数只可读,加out可以将外部变量传入函数里面。类似引用
int func_in(in int x,out int y){
y = x+1;
return x;
}
dlang中也支持静态值
static int func_count = 0;
void func_call(int x){
++func_count;
//writeln(func_count);
}
dlang函数中的泛型,让函数更加通用
//the generic
T[] findListG(T)(T[] list,T search){
while(list.length > 0 && list[0] != search){
list = list[1..$];
}
return list;
}
int[] mylist = [1,2,3,4,5];
assert(findListG!(int)(mylist,3) == [3,4,5]);
//int to double
double[] mylist2 = [1,1.1,2.1,3.1,4.1,5.1,3];
assert(findListG(mylist2,3) == [3]);
//assert(findListG(mylist2,"hi") == []);//error
dlang函数前可以加上参数约束。typeof判断类型,is判断两者比较的结果是不是bool
T[] findListG2(T,E)(T[] list,E search)
if(is(typeof(T[0] != search) == bool))
{
while(list.length > 0 && list[0] != search){
list = list[1..$];
}
return list;
}
assert(findListG2(mylist2,3) == [3]);//error
让上面的find函数更加通用
T1[] findListG3(T1,T2)(T1[] longer, T2[] shorter)
if(is(typeof(longer[0..1] == shorter) :bool))
{
while(longer.length > shorter.length){
if(longer[0..shorter.length] == shorter) break;
longer = longer[1..$];
}
return longer;
}
dlang中函数重载会根据参数的范围调用函数,优先调用小范围的。
bool myprint(int x){
return is(typeof(x) == int);
}
bool myprint(double x){
return is(typeof(x) == double);
}
myprint(1);//优先调用myprint(int x)
dlang的高阶函数.允许使用函数别名
//senior function
T[] findSenior(alias pred,T)(T[] input)
if(is(typeof(pred(input[0])) == bool))
{
for(;input.length >0;input = input[1..$]){
if(pred(input[0])) break;
}
return input;
}
auto senior_list = [22,3,12,-7,-9,32];
//调用函数
assert(findSenior!(function bool(int x){return x > 30;})(senior_list) == [32]);
int z = 30;
//senior function delegate调用委托函数。委托函数可以访问外部变量
assert(findSenior!(delegate bool(int x){return x > z;})(senior_list) == [32]);
auto myfunc = function bool(int x){ return x < 0;};
auto senior_list2 = findSenior!(myfunc)(senior_list);
//auto list2 = findSenior!(myfunc,int)(list);
assert( senior_list2 == [-7, -9, 32]);
dlang函数内部的函数
//function in function
int[] outfunction(int[] input,int z){
bool infunction(int x){
return x >= z;
}
static int zz = 30;
static bool infunction2(int x){
return x > zz;
}
return findSenior!(infunction2)(input);
}
dlang的闭包。下面的闭包里面局部变量x在传参后可以保持不变。
//closure function
T[] delegate(T[])finder(T)(T x)
if(is(typeof(x == x) == bool))
{
return delegate(T[] a){ return findListG(a,x);};
}
auto delegate_func = finder(5);
auto delegate_func_new = finder("ho");
//senior function test
auto senior_list = [22,3,12,-7,-9,32];
int z = 30;
assert(delegate_func([1,2,3,4,5,6]) == [5,6]);
assert(delegate_func_new(["hi","ho","wo"]) == ["ho","wo"]);
dlang的同构可变函数采用 value...定义。简单说就是结构相同,参数个数可以变化
double average(double[] values...){
writeln("in value...");
if(values.empty){
throw new Exception("values is zero");
}
return reduce!((a,b){return a+b;})(0.0,values)/values.length;
}
double average(double[] values){
writeln("in no value ...");
if(values.empty){
throw new Exception("values is zero");
}
return reduce!((a,b){return a+b;})(0.0,values)/values.length;
}
double[] double_v = [1,2];
assert(average(double_v) == 1.5 );
assert(average(1,2) == 1.5);
assert(average(1.1,2.1) == 1.6);
结构不同内容也不同的函数
void writeln_m(T...)(T args){
foreach(arg;args){
stdout.rawWrite(to!string(arg));
}
stdout.rawWrite("\n");
stdout.flush();
foreach(k,v;args){
writeln(k,":",typeid(T[k]),"~~",v);
}
}
writeln_m(1,2,1.1,"hell",[1,23]);
dlang中的元组。元组主要用来打包函数参数可以让可变参数任意的传递
Tuple!(int,double) tuple_v = tuple(1,1.2);
void fun(T...)(T args){
//writeln(typeof(args).stringof);
gun(tuple(args));
}
void gun(T)(T value){
writeln(value.expand);
}
pure参数修饰的纯函数,只依赖自己的参数或者其他纯函数的函数
pure int mypure(int x){
//writeln(x); //error
return x+10;
}
不抛出异常的函数
nothrow void tryThrow(){
try{
throw new Exception("catch Exception");
}catch{
//writeln("has catch!");//error
}
}