Lập trình D - Chức năng

Chương này mô tả các hàm được sử dụng trong lập trình D.

Định nghĩa hàm trong D

Định nghĩa hàm cơ bản bao gồm tiêu đề hàm và thân hàm.

Cú pháp

return_type function_name( parameter list ) { 
   body of the function 
}

Đây là tất cả các phần của một hàm -

• Return Type- Một hàm có thể trả về một giá trị. Cácreturn_typelà kiểu dữ liệu của giá trị mà hàm trả về. Một số hàm thực hiện các hoạt động mong muốn mà không trả về giá trị. Trong trường hợp này, return_type là từ khóavoid.

• Function Name- Đây là tên thực của hàm. Tên hàm và danh sách tham số cùng nhau tạo thành chữ ký hàm.

• Parameters- Một tham số giống như một trình giữ chỗ. Khi một hàm được gọi, bạn chuyển một giá trị cho tham số. Giá trị này được gọi là tham số hoặc đối số thực tế. Danh sách tham số đề cập đến kiểu, thứ tự và số lượng các tham số của một hàm. Các thông số là tùy chọn; nghĩa là, một hàm có thể không chứa tham số.

• Function Body - Phần thân hàm chứa một tập hợp các câu lệnh xác định chức năng thực hiện.

Gọi một hàm

Bạn có thể gọi một hàm như sau:

function_name(parameter_values)

Các loại hàm trong D

Lập trình D hỗ trợ một loạt các chức năng và chúng được liệt kê dưới đây.

• Chức năng thuần túy
• Hàm Nothrow
• Chức năng phản chiếu
• Chức năng tự động
• Các chức năng đa dạng
• Chức năng Inout
• Chức năng tài sản

Các chức năng khác nhau được giải thích bên dưới.

Chức năng thuần túy

Các hàm thuần túy là các hàm không thể truy cập lưu trạng thái toàn cục hoặc tĩnh, có thể thay đổi thông qua các đối số của chúng. Điều này có thể cho phép tối ưu hóa dựa trên thực tế là một hàm thuần túy được đảm bảo sẽ thay đổi không có gì không được truyền cho nó và trong trường hợp trình biên dịch có thể đảm bảo rằng một hàm thuần túy không thể thay đổi các đối số của nó, nó có thể kích hoạt độ tinh khiết đầy đủ của hàm là, đảm bảo rằng hàm sẽ luôn trả về cùng một kết quả cho các đối số giống nhau).

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)); 
}

Khi đoạn mã trên được biên dịch và thực thi, nó tạo ra kết quả sau:

Value returned from pure function : 30

Hàm Nothrow

Các hàm Nothrow không ném bất kỳ ngoại lệ nào bắt nguồn từ Exception của lớp. Các hàm Nothrow đồng biến với các hàm ném.

Nothrow đảm bảo rằng một hàm không phát ra bất kỳ ngoại lệ nào.

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)); 
}

Khi đoạn mã trên được biên dịch và thực thi, nó tạo ra kết quả sau:

adding 
Added value is 30

Chức năng phản chiếu

Các hàm tham chiếu cho phép các hàm trả về bằng tham chiếu. Điều này tương tự với các tham số hàm 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);   
}

Khi đoạn mã trên được biên dịch và thực thi, nó tạo ra kết quả sau:

a: 1, b: 12

Chức năng tự động

Các chức năng tự động có thể trả về giá trị thuộc bất kỳ kiểu nào. Không có hạn chế về loại được trả lại. Dưới đây là một ví dụ đơn giản cho chức năng loại tự động.

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)); 
}

Khi đoạn mã trên được biên dịch và thực thi, nó tạo ra kết quả sau:

add(a,b) = 3.5

Các chức năng đa dạng

Các hàm đa dạng là những hàm trong đó số lượng tham số cho một hàm được xác định trong thời gian chạy. Trong C, có một hạn chế là có ít nhất một tham số. Nhưng trong lập trình D, không có giới hạn như vậy. Một ví dụ đơn giản được hiển thị bên dưới.

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); 
}

Khi đoạn mã trên được biên dịch và thực thi, nó tạo ra kết quả sau:

int 2 
long 3 
double 4.5

Chức năng Inout

Inout có thể được sử dụng cho cả kiểu tham số và trả về của hàm. Nó giống như một khuôn mẫu cho biến, hằng và bất biến. Thuộc tính biến đổi được suy ra từ tham số. Có nghĩa là, inout chuyển thuộc tính biến đổi được suy ra thành kiểu trả về. Dưới đây là một ví dụ đơn giản cho thấy khả năng biến đổi được thay đổi như thế nào.

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); 
}

Khi đoạn mã trên được biên dịch và thực thi, nó tạo ra kết quả sau:

char[] "test a" 
const(char)[] "test b" 
string "test c"

Chức năng tài sản

Thuộc tính cho phép sử dụng các hàm thành viên giống như các biến thành viên. Nó sử dụng từ khóa @property. Các thuộc tính được liên kết với chức năng liên quan trả về giá trị dựa trên yêu cầu. Một ví dụ đơn giản cho tài sản được hiển thị bên dưới.

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); 
}

Khi đoạn mã trên được biên dịch và thực thi, nó tạo ra kết quả sau:

The area is 200 
Value set! 
Modified width is 30