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

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
 

Ծրագրավորման լեզուներ
Օբյեկտ կողմնորոշված ծրագրավորման լեզուներ