D语言之函数

参考自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
	}
}