2016-06-26 12:32:15 +00:00
- - -
language: D
2016-06-26 12:32:48 +00:00
filename: learnd - hd . d
2016-06-26 12:32:15 +00:00
contributors:
- [ "Nick Papanastasiou" , "www.nickpapanastasiou.github.io" ]
2016-06-26 12:32:48 +00:00
lang: hd
2016-06-26 12:32:15 +00:00
- - -
`` ` c
//क्या आ रहा है पता है ...
module hello ;
import std.stdio ;
void main ( string [ ] args ) {
writeln ( "Hello, World!" ) ;
}
`` `
अगर आप मेरे जैसे हैं और इंटरनेट पर समय बहुत अध ि क समय खर्च करते हैं , त ो आप ब ा ध ा ओं के ब ा रे में सुन ा है
के ब ा रे में [ ड ी ] ( http : //dlang.org/ )। डी प्रोग्रामिंग भाषा में एक आधुनिक, सामान्य प्रयोजन है ,
सब कुछ के ल ि ए समर्थन कम स्तर क ी सुव ि ध ा ओं से करने के स ा थ बहु - प्रत ि म ा न भ ा ष ा
अर्थपूर्ण उच्च स्तर ी य च ी जें ।
D सक्र ि य रूप से सुपर स्म ा र्ट ल ो ग ो ं क ा एक बड़ ा समूह द्व ा र ा व ि कस ि त क ी है और नेतृत्व द्व ा र ा क ि य ा ज ा त ा है
[ व ा ल्टर ब्र ा इट ] ( https : //en.wikipedia.org/wiki/Walter_Bright ) और
[ आंद्रेई Alexandrescu ] ( https : //en.wikipedia.org/wiki/Andrei_Alexandrescu )।
ज ि स तरह क ी है क ि सभ ी के स ा थ ब ा हर , चल ो कुछ उद ा हरण ो ं पर ग ौ र करते हैं !
`` ` c
import std.stdio ;
void main ( ) {
for ( int i = 0 ; i < 10000 ; i + + ) {
writeln ( i ) ;
}
// 'auto' can be used for inferring types.
auto n = 1 ;
// संख्यात्मक literals स्पष्टता के लिए एक अंकों विभाजक के रूप में '_' का उपयोग कर सकते हैं।
while ( n < 10_000 ) {
n + = n ;
}
do {
n - = ( n / 2 ) ;
} while ( n > 0 ) ;
// लिए और जब तक अच्छा कर रहे हैं, लेकिन D में हम 'foreach' छोरों पसंद करते हैं।
// '..' पहला मान सहित एक सतत श्रृंखला बनाता है,
// लेकिन पिछले छोड़कर।
foreach ( i ; 1. . 1_000_000 ) {
if ( n % 2 = = 0 )
writeln ( i ) ;
}
// वहाँ भी 'foreach_reverse' आप पीछे की ओर पाश करना चाहते हैं।
foreach_reverse ( i ; 1. . int . max ) {
if ( n % 2 = = 1 ) {
writeln ( i ) ;
} else {
writeln ( "No!" ) ;
}
}
}
`` `
हम ' struct `, `c lass `,` union `, और ` ` enum` स ा थ नए प्रक ा र पर ि भ ा ष ि त कर सकते हैं । Structs और unions
मूल्य से क ा र्य करने के ल ि ए प ा र ि त कर रहे हैं ( य ा न ी नकल ) और वर्ग ो ं के संदर्भ द्व ा र ा प ा र ि त कर रहे हैं । इसके अल ा व ा ,
हम प्रक ा र ो ं और म ा न ो ं द ो न ो ं पर करने के ल ि ए टेम्पलेट क ा उपय ो ग कर सकते हैं !
`` ` c
// इधर, 'T' एक प्रकार पैरामीटर है। लगता है कि '<+T>' C++ / C/ Java से।
struct LinkedList ( T ) {
T data = null ;
// '!'का प्रयोग करें , एक पैरामिट्रीकृत प्रकार इन्स्तांत । फिर, '<T >' लगता है।
LinkedList ! ( T ) * next ;
}
class BinTree ( T ) {
T data = null ;
// केवल एक टेम्पलेट पैरामीटर नहीं है, तो , हम कोष्ठकों छोड़ सकते हैं।
BinTree ! T left ;
BinTree ! T right ;
}
enum Day {
Sunday ,
Monday ,
Tuesday ,
Wednesday ,
Thursday ,
Friday ,
Saturday ,
}
// उपयोग उर्फ प्रकार (alias) के लिए संक्षिप्त बनाने के लिए।
alias IntList = LinkedList ! int ;
alias NumTree = BinTree ! double ;
//हम के रूप में अच्छी तरह से कार्य टेम्पलेट्स बना सकते हैं!
T max ( T ) ( T a , T b ) {
if ( a < b )
return b ;
return a ;
}
// संदर्भ द्वारा पारित सुनिश्चित करने के लिए रेफरी कीवर्ड का प्रयोग करें । यही कारण है कि यहां तक कि 'A' और 'B' , तो है
//मान प्रकार वे हमेशा ' swap()' के संदर्भ द्वारा पारित हो जाएगा हैं ।
void swap ( T ) ( ref T a , ref T b ) {
auto temp = a ;
a = b ;
b = temp ;
}
// टेम्पलेट्स के साथ, हम भी मूल्यों पर परमेटेराइज़ कर सकते हैं , न सिर्फ types.With टेम्पलेट्स, हम भी नहीं है, बस प्रकार , मूल्यों पर parameterize कर सकते हैं।
class Matrix ( uint m , uint n , T = int ) {
T [ m ] rows ;
T [ n ] columns ;
}
auto mat = new Matrix ! ( 3 , 3 ) ;
`` `
Classes क ी ब ा त ह ो रह ी है , एक दूसरे के ल ि ए गुण ो ं के ब ा रे में ब ा त करते हैं । एक संपत्त ि
एक value क ी तरह क ा र्य कर सकते हैं क ि एक सम ा र ो ह में म ो टे त ौ र पर है , इसल ि ए हम कर सकते हैं
के शब्द ो ं के स ा थ प ॉ ड संरचन ा ओं क ी व ा क्य रचन ा ( ` structure.x = 7` ) है
मनुष्य और सेटर तर ी क ो ं ( ` object.setX (7) ` ) !
`` ` c
// Consider a class parameterized on types 'T' & 'U'.
class MyClass ( T , U ) {
T _data ;
U _other ;
}
// And "getter" and "setter" methods like so:
class MyClass ( T , U ) {
T _data ;
U _other ;
// भवन निर्माताओं हमेशा नामित कर रहे हैं 'this'.
this ( T t , U u ) {
//यह नीचे सेटर तरीकों से मुलाकात करेंगे।
data = t ;
other = u ;
}
// getters
@property T data ( ) {
return _data ;
}
@property U other ( ) {
return _other ;
}
// setters
@property void data ( T t ) {
_data = t ;
}
@property void other ( U u ) {
_other = u ;
}
}
//और हम इस तरह से उन का उपयोग करें :
void main ( ) {
auto mc = new MyClass ! ( int , string ) ( 7 , "seven" ) ;
2024-04-04 11:02:42 +00:00
// करने के लिए लिखने के लिए मानक पुस्तकालय से
// आयात ' stdio ' मॉड्यूल
2016-06-26 12:32:15 +00:00
// सांत्वना (आयात एक गुंजाइश के लिए स्थानीय हो सकता है) ।
import std.stdio ;
// Call the getters to fetch the values.
writefln ( "Earlier: data = %d, str = %s" , mc . data , mc . other ) ;
// Call the setters to assign new values.
mc . data = 8 ;
mc . other = "eight" ;
// Call the getters again to fetch the new values.
writefln ( "Later: data = %d, str = %s" , mc . data , mc . other ) ;
}
`` `
गुण ो ं के स ा थ , हम तर्क क ी क ि स ी भ ी र ा श ि क ो ज ो ड़ सकते हैं
हम ा रे मनुष्य और सेटर तर ी क ो ं , और क ी स ा फ व ा क्य रचन ा रखन ा
स ी धे सदस्य ो ं तक पहुँचने !
हम ा रे न ि पट ा न पर अन्य वस्तु उन्मुख उपह ा र
` interface` s , ` सार class` es श ा म ि ल
और ` तरीकों override` ing । ड ी स ि र्फ ज ा व ा क ी तरह व ि र ा सत करत ा है :
आप कृपय ा के रूप में कई इंटरफेस क ो ल ा गू करने , एक वर्ग क ा व ि स्त ा र ।
हम ड ी एस OOP सुव ि ध ा ओं देख ा , लेक ि न स्व ि च ग ि यर छ ो ड़ द ि य ा । ड ी प्रस्त ा व ो ं
प्रथम श्रेण ी के क ा र्य ो ं के स ा थ क ा र्य ा त्मक प्र ो ग्र ा म ि ंग , ` pure`
क ा म करत ा है , और अपर ि वर्तन ी य डेट ा । इसके अल ा व ा , अपने पसंद ी द ा के सभ ी
क ा र्य ा त्मक एल्ग ो र ि दम ( नक्श ा , फ ि ल्टर , कम करने और म ि त्र ह ो सकते हैं )
अद्भुत ` std.algorithm` म ॉ ड्यूल में प ा य ा !
`` ` c
import std.algorithm : map , filter , reduce ;
import std.range : iota ; // builds an end-exclusive range
void main ( ) {
// हम भी ints के वर्गों की एक सूची का योग मुद्रित करना चाहते हैं
// 1 से 100 के लिए आसान करने के लिए!
// बस टेम्पलेट पैरामीटर के रूप में लैम्ब्डा भाव के पास!
// आप आप की तरह किसी भी पुराने समारोह पारित कर सकते हैं , लेकिन lambdas यहाँ सुविधाजनक हैं।
auto num = iota ( 1 , 101 ) . filter ! ( x = > x % 2 = = 0 )
. map ! ( y = > y ^ ^ 2 )
. reduce ! ( ( a , b ) = > a + b ) ;
writeln ( num ) ;
}
`` `
हम NUM गणन ा करने के ल ि ए एक अच्छ ा Haskellian प ा इपल ा इन क ा न ि र्म ा ण करने के ल ि ए म ि ल ा सूचन ा कैसे ?
यह ी क ा रण है क ि एक ड ी नव ा च ा र करने के ल ि ए धन्यव ा द वर्द ी सम ा र ो ह क ॉ ल स ि ंटेक्स के रूप में ज ा नते हैं ।
UFCS के स ा थ , हम एक व ि ध ि के रूप में एक सम ा र ो ह क ॉ ल ल ि खने के ल ि ए चुन सकते हैं
य ा मुफ्त सम ा र ो ह क ॉ ल ! व ा ल्टर इस पर एक अच्छ ा लेख ल ि ख ा थ ा
[ यह ा ँ । ] ( http : //www.drdobbs.com/cpp/uniform-function-call-syntax/232700394 )
संक्षेप में , आप ज ि नक ी पहल ी पैर ा म ी टर क ा र्य ो ं क ॉ ल कर सकते हैं
एक व ि ध ि के रूप में ग्रुप ए क ी क ि स ी भ ी अभ ि व्यक्त ि पर कुछ प्रक ा र एक क ी है ।
मैं सम ा नत ा च ा हते । सम ा नत ा क ी तरह क ो ई और ? ज़रूर तुम करन ा । चल ो कुछ करते हैं !
2024-04-04 11:02:42 +00:00
2016-06-26 12:32:15 +00:00
`` ` c
import std.stdio ;
import std.parallelism : parallel ;
import std.math : sqrt ;
void main ( ) {
2024-04-04 11:02:42 +00:00
// हम हमारे सरणी में वर्गमूल हर नंबर ले जाना चाहता हूँ ,
// हम उपलब्ध है के रूप में और के रूप में कई कोर का लाभ ले।
2016-06-26 12:32:15 +00:00
auto arr = new double [ 1_000_000 ] ;
2024-04-04 11:02:42 +00:00
// संदर्भ के द्वारा एक सूचकांक , और एक सरणी तत्व का प्रयोग
2016-06-26 12:32:15 +00:00
// और सिर्फ सरणी पर समानांतर फोन!
foreach ( i , ref elem ; parallel ( arr ) ) {
ref = sqrt ( i + 1.0 ) ;
}
}
`` `