From Wikipedia, the free encyclopedia
D–ն, օբյեկտակողմնորորշված, համակարգային ծրագրավորման լեզու է։ Ստեղծել է Ուոլթեր Բրայթը (անգլ. Walter Bright)։ D–ի ստեղծումը և զարգացումը սկսվել է 1999 թվականին և առաջին անգամ թողարկվել է 2001 թվականին։ Հիմնական տարբերակը՝ D (1.0), թողարկվել է 2007 թվականին։ Արդեն կա նաև D2 տարբերակը։ D–ի քերականությունը նման է C–ին։ D–ն շատ նմանություններ ունի C–ի և C++–ի հետ, սակայն ունի նաև թվարկված լեզունների հետ կապ չունեցող առանձնահատկություններ։ D–ն բազմաբնույթ նմուշային ծրագրավորման լեզու է, այսինքն՝ նրանում առկա են օբյեկտային կողմնորոշվածություն, մետածրագրավորում, ֆունկցիոնալ և մրցակցային ծրագրավորում։
Այս հոդվածն աղբյուրների կարիք ունի։ Դուք կարող եք բարելավել հոդվածը՝ գտնելով բերված տեղեկությունների հաստատումը վստահելի աղբյուրներում և ավելացնելով դրանց հղումները հոդվածին։ Անհիմն հղումները ենթակա են հեռացման։ |
![]() | |
---|---|
Տեսակ | օբյեկտ կողմնորոշված ծրագրավորման լեզու, ծրագրավորման պրոցեդուրային լեզու, ֆունկցիոնալ ծրագրավորման լեզու, ընդհանուր ծրագրավորման լեզու, concurrent programming language?, բազմահարացուցային ծրագրավորման լեզու, իմպերատիվ ծրագրավորման լեզու, ծրագրավորման կոմպիլյացվող լեզու և ծրագրավորման լեզու |
Առաջացել է | դեկտեմբերի 8, 2001 |
Ստեղծող | Walter Bright? և D Language Foundation? |
Նախագծող | Walter Bright? |
Ընդլայնումներ | .d , .dd , .di և .def |
Ներշնչվել է | C++, C, C Sharp, Eiffel, Ջավա և Python |
Հմայագիր | D-Man? |
Կայք | dlang.org |
![]() |
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–ում իրականացվում է երեք տարբերակով՝
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) կառուցվածք է, որը հնարավորություն է տալիս գեներացվող կոդի միացումը սկզբնական կոդի։ Լինում է երեք տարբերակ
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
Seamless Wikipedia browsing. On steroids.
Every time you click a link to Wikipedia, Wiktionary or Wikiquote in your browser's search results, it will show the modern Wikiwand interface.
Wikiwand extension is a five stars, simple, with minimum permission required to keep your browsing private, safe and transparent.