D (ծրագրավորման լեզու)

Անվան այլ կիրառումների համար տե՛ս՝ D (այլ կիրառումներ)

D

Տեսակ	օբյեկտ կողմնորոշված ծրագրավորման լեզու, ծրագրավորման պրոցեդուրային լեզու, ֆունկցիոնալ ծրագրավորման լեզու, ընդհանուր ծրագրավորման լեզու, concurrent programming language?, բազմահարացուցային ծրագրավորման լեզու, իմպերատիվ ծրագրավորման լեզու, ծրագրավորման կոմպիլյացվող լեզու և ծրագրավորման լեզու
Առաջացել է	դեկտեմբերի 8, 2001
Ստեղծող	Walter Bright? և D Language Foundation?
Նախագծող	Walter Bright?
Ընդլայնումներ	.d, .dd, .di և .def
Ներշնչվել է	C++, Սի (ծրագրավորման լեզու), C Sharp, Eiffel, Ջավա և Python
Հմայագիր	D-Man?
Կայք	dlang.org
D programming language Վիքիպահեստում

D–ն, օբյեկտակողմնորորշված, համակարգային ծրագրավորման լեզու է։ Ստեղծել է Ուոլթեր Բրայթը (անգլ. Walter Bright)։ D–ի ստեղծումը և զարգացումը սկսվել է 1999 թվականին և առաջին անգամ թողարկվել է 2001 թվականին։ Հիմնական տարբերակը՝ D (1.0), թողարկվել է 2007 թվականին։ Արդեն կա նաև D2 տարբերակը։ D–ի քերականությունը նման է C–ին։ D–ն շատ նմանություններ ունի C–ի և C++–ի հետ, սակայն ունի նաև թվարկված լեզունների հետ կապ չունեցող առանձնահատկություններ։ D–ն բազմաբնույթ նմուշային ծրագրավորման լեզու է, այսինքն՝ նրանում առկա են օբյեկտային կողմնորոշվածություն, մետածրագրավորում, ֆունկցիոնալ և մրցակցային ծրագրավորում։

Հիմնական քերականություն

import std.stdio;

void main(string[] args)
{
   writeln("test!");
}

Ծրագրի օգտագործման տարբերակը

$ dmd test.d
$ ./test

Արդյունքում կտպի

test

Փոփոխականներ

Փոփոխականները D–ում ունեն բնորոշ տիպերը, որը որոշում է տրված փոփոխականի չափսը հիշողության տարածքում։ Փոփոխականները D–ում կարող են լինել հետևյալ տիպերի. char, int, float, double, void։ Փոփոխականների օգտագործման օրինակ՝

import std.stdio;

int a = 10, b =10;
int c;
float f;

int main ()
{
 writeln("Value of a is : ", a);
 
  int a, b;
  int c;
  float f;

  
  a = 30;
  b = 40;
  writeln("Value of a is : ", a);
  c = a + b;
 writeln("Value of c is : ", c);

  f = 70.0/3.0;
 writeln("Value of f is : ", f);
  return 0;
}

Կոմպիլյացիայի արդյունքում հետևյալ պատասխանը ցույց կտա՝

Value of a is : 10
Value of a is : 30
Value of c is : 70
Value of f is : 23.3333

Պայմանագրային ծրագրավորումը D–ում

Պայմանագրային ծրագրավորումը D–ում կենտրոնացված է, որպեսզի ապահովի պարզ և հասկանալի միջոցներ սխալների հայտնաբերման համար։ Այն D–ում իրականացվում է երեք տարբերակով՝

1)body block

2)in block

3)out block

body block–ը պարունակում է արդիական ֆունկցիոնալություն կոդի կատարման համար։ In և out block–ները գործում են, քանի դեռ body block պարտադիր է։ Սովորական քերականությունը տրված է այստեղ։

 
return_type function_name(function_params)
in
{
   // բլոկում
}
out (result)
{
   // բլոկում
}
body
{
   // արդիական ֆունկցիայի  բլոկում
}

in block–ը նախատեսված է սովորական նախապայմանների համար, որպեսզի ստուգի, թե ներմուծված պարամետրերը ընդունելի են թե ոչ և տրված տիրույթում կարող են հայտնաբերվել կոդի օգնությամբ։Block–ի առավելությունն այն է, որ բոլոր մուտքային պայմանները պահվում են միասին և բաժանվում են ֆունկցիայի գործող մասից։

 
import std.stdio;
import std.string;

bool isValid(string password)
in
{
   assert(password.length>=5);
}
body
{
   // ուրիշ պայմաններ
   return true;
}

void main()
{
   writeln(isValid("password"));
}

Երբ վերը նշված կոդը կոմպիլացվում և կատարվում է, ցույց է տալիս հետևյալ պատասխանը։

true

out block–ը ապահովում է ֆունկցիայի վերադարձնող արժեքները։ Այն հաստատում է, որ վերադարձնող արժեքը գտնվում է ակնկալվող տիրույթում։

import std.stdio;
import std.string;

double getAge(double months,double years)
in
{
   assert(months >= 0);
   assert(months <= 12);
}
out (result)
{
   assert(result>=years);
}
body
{
   return years + months/12;
}

void main ()
{
   writeln(getAge(10,12));
}

Երբ վերը նշված կոդը կոմպիլացվում և կատարվում է, ցույց է տալիս հետևյալ պատասխանը։

12.8333

Խառնուրդներ (Mixins)

Խառնուրդը (Mixins) կառուցվածք է, որը հնարավորություն է տալիս գեներացվող կոդի միացումը սկզբնական կոդի։ Լինում է երեք տարբերակ

1) String Mixins

2)Template Mixins

3)Mixin name spaces

String Mixins D–ն հնարավորություն ունի մուտքագրել տողը որպես long, եթե իհարկե այդ տողը հայտնի է կոմպիլացիայի ժամանակ։

mixin (compile_time_generated_string)

Տվյալ օրինակը ցույց է տալիս տողային խառնուրդը (Mixins)։

import std.stdio;

void main()
{
   mixin(`writeln("Hello World!");`);
}

Երբ վերը նշված կոդը կոմպիլացվում և կատարվում է, ցույց է տալիս հետևյալ պատասխանը։

Hello World!

Կարելի է նաև ներկայացնել մեկ այլ օրինակ, որտեղ կարելի է փոխանցել տողը կոմպիլիացյիայի ընթացքում, այնպես որ խառնուրդը (Mixins) կարող է օգտագործել ֆունկցիան կրկնակի օգտագործման համար։

import std.stdio;

string print(string s)
{
   return `writeln("` ~ s ~ `");`;
}

void main()
{
   mixin (print("str1"));
   mixin (print("str2"));
}

Երբ վերը նշված կոդը կոմպիլացվում և կատարվում է, ցույց է տալիս հետևյալ պատասխանը։

str1
str2

Template Mixins D–ն սահմանում է ընդհանուր կոդի կաղապարները, որպեսզի կոմպիլիատորը գեներացնի ընդհանուր օրինակները տրված կաղապարներից։ Կաղապարները կարող են գեներացնել կառուցվածքներ, կլասներ, ֆունկցիաներ։

mixin a_template!(template_parameters)

Սովորական օրինակը տրված է այստեղ։

import std.stdio;

template Department(T, size_t count)
{
   T[count] names;

   void setName(size_t index, T name)
   {
      names[index] = name;
   }

   void printNames()
   {
      writeln("The names");

      foreach (i, name; names) 
      {
         writeln(i," : ", name);
      }
   }
}

struct College
{
   mixin Department!(string, 2);
}

void main()
{
   auto college = College();

   college.setName(0, "name1");
   college.setName(1, "name2");

   college.printNames();
}

Երբ վերը նշված կոդը կոմպիլացվում և կատարվում է, ցույց է տալիս հետևյալ պատասխանը։

The names
0 : name1
1 : name2

Mixin name spaces Mixin name space–ը օգտագործում են, որպեսզի խուսափեն կաղապարների երկիմաստություններից։ Որպես օրինակ կարեի է դիտարկել երկու փոփոխականներ, որոնցից մեկը հայտատրված է main–ում, իսկ մյուսը միքսին է։ Եթե խառնուրդի (Mixins) անունը նույնն է, ինչ որ շրջակա շրջանակում, ապա օգտագործվում է այդ անունը։

import std.stdio;

template Person()
{
   string name;
   void print()
   {
      writeln(name);
   }
}

void main()
{
   string name;

   mixin Person a;

   name = "name 1";
   writeln(name);

   a.name = "name 2";
   print();
}

Երբ վերը նշված կոդը կոմպիլացվում և կատարվում է, ցույց է տալիս հետևյալ պատասխանը։

name 1
name 2