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

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

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

```d
import std.stdio;

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

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

```d
$ dmd test.d
$ ./test
```


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

```d
test
```


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

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


```d
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;
}
```


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

```d
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 պարտադիր է։ Սովորական քերականությունը տրված է այստեղ։

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


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


```d
import std.stdio;
import std.string;

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

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


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

```d
true
```


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

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


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

```d
12.8333
```


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

1) String Mixins

2)Template Mixins

3)Mixin name spaces

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


```d
mixin (compile_time_generated_string)
```


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

```d
import std.stdio;

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


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

```d
Hello World!
```


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

```d
import std.stdio;

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

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


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

```d
str1
str2
```


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


```d
mixin a_template!(template_parameters)
```


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

```d
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();
}
```


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

```d
The names
0 : name1
1 : name2
```


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

```d
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();
}
```


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

```d
name 1
name 2
```


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