📅 最后修改于: 2020-11-04 05:09:09 🧑 作者: Mango
本章介绍D编程中使用的功能。
基本函数定义由函数头和函数体组成。
return_type function_name( parameter list ) {
body of the function
}
这是函数的所有部分-
返回类型-函数可以返回一个值。 return_type是函数返回的值的数据类型。某些函数执行所需的操作而不返回值。在这种情况下，return_type是关键字void 。
功能名称-这是函数的实际名称。函数名称和参数列表共同构成函数签名。
参数-参数就像一个占位符。调用函数，将一个值传递给参数。此值称为实际参数或自变量。参数列表是指类型，顺序和数量的函数的参数。参数是可选的；也就是说，一个函数可能不包含任何参数。
函数体-函数体包含定义函数的语句的集合。
您可以按以下方式调用函数-
function_name(parameter_values)
D编程支持多种功能，下面列出了它们。
下面说明各种功能。
纯函数是无法通过其参数访问全局或静态，可变状态的函数。这可以基于以下事实进行优化：保证纯函数不对没有传递给它的任何东西进行突变，并且在编译器可以保证纯函数不能更改其参数的情况下，它可以启用完整的函数纯净，是，保证函数将始终为相同的参数返回相同的结果)。
import std.stdio;
int x = 10;
immutable int y = 30;
const int* p;
pure int purefunc(int i,const char* q,immutable int* s) {
//writeln("Simple print"); //cannot call impure function 'writeln'
debug writeln("in foo()"); // ok, impure code allowed in debug statement
// x = i; // error, modifying global state
// i = x; // error, reading mutable global state
// i = *p; // error, reading const global state
i = y; // ok, reading immutable global state
auto myvar = new int; // Can use the new expression:
return i;
}
void main() {
writeln("Value returned from pure function : ",purefunc(x,null,null));
}
编译并执行上述代码后，将产生以下结果-
Value returned from pure function : 30
Nothrow函数不会抛出任何从Exception类派生的异常。没有throw函数与throwing函数协变。
Nothrow保证函数不会发出任何异常。
import std.stdio;
int add(int a, int b) nothrow {
//writeln("adding"); This will fail because writeln may throw
int result;
try {
writeln("adding"); // compiles
result = a + b;
} catch (Exception error) { // catches all exceptions
}
return result;
}
void main() {
writeln("Added value is ", add(10,20));
}
编译并执行上述代码后，将产生以下结果-
adding
Added value is 30
引用函数允许函数通过引用返回。这类似于ref函数参数。
import std.stdio;
ref int greater(ref int first, ref int second) {
return (first > second) ? first : second;
}
void main() {
int a = 1;
int b = 2;
greater(a, b) += 10;
writefln("a: %s, b: %s", a, b);
}
编译并执行上述代码后，将产生以下结果-
a: 1, b: 12
自动功能可以返回任何类型的值。对于要返回的类型没有任何限制。自动键入函数的简单示例如下。
import std.stdio;
auto add(int first, double second) {
double result = first + second;
return result;
}
void main() {
int a = 1;
double b = 2.5;
writeln("add(a,b) = ", add(a, b));
}
编译并执行上述代码后，将产生以下结果-
add(a,b) = 3.5
可变参数函数是在运行时确定函数参数数量的那些函数。在C语言中，存在至少一个参数的限制。但是在D编程中，没有这种限制。一个简单的例子如下所示。
import std.stdio;
import core.vararg;
void printargs(int x, ...) {
for (int i = 0; i < _arguments.length; i++) {
write(_arguments[i]);
if (_arguments[i] == typeid(int)) {
int j = va_arg!(int)(_argptr);
writefln("\t%d", j);
} else if (_arguments[i] == typeid(long)) {
long j = va_arg!(long)(_argptr);
writefln("\t%d", j);
} else if (_arguments[i] == typeid(double)) {
double d = va_arg!(double)(_argptr);
writefln("\t%g", d);
}
}
}
void main() {
printargs(1, 2, 3L, 4.5);
}
编译并执行上述代码后，将产生以下结果-
int 2
long 3
double 4.5
inout可用于函数的参数和返回类型。它就像是可变，常量和不可变的模板。可变性属性是从参数推导出的。意味着，inout将推导的可变性属性转换为返回类型。下面显示了一个简单的示例，显示了如何更改可变性。
import std.stdio;
inout(char)[] qoutedWord(inout(char)[] phrase) {
return '"' ~ phrase ~ '"';
}
void main() {
char[] a = "test a".dup;
a = qoutedWord(a);
writeln(typeof(qoutedWord(a)).stringof," ", a);
const(char)[] b = "test b";
b = qoutedWord(b);
writeln(typeof(qoutedWord(b)).stringof," ", b);
immutable(char)[] c = "test c";
c = qoutedWord(c);
writeln(typeof(qoutedWord(c)).stringof," ", c);
}
编译并执行上述代码后，将产生以下结果-
char[] "test a"
const(char)[] "test b"
string "test c"
属性允许使用成员函数(如成员变量)。它使用@property关键字。这些属性与相关的函数链接，这些函数根据需求返回值。一个简单的属性示例如下所示。
import std.stdio;
struct Rectangle {
double width;
double height;
double area() const @property {
return width*height;
}
void area(double newArea) @property {
auto multiplier = newArea / area;
width *= multiplier;
writeln("Value set!");
}
}
void main() {
auto rectangle = Rectangle(20,10);
writeln("The area is ", rectangle.area);
rectangle.area(300);
writeln("Modified width is ", rectangle.width);
}
编译并执行上述代码后，将产生以下结果-
The area is 200
Value set!
Modified width is 30