నిర్మాణం
అవలోకనం
Wave భాషలోని నిర్మాణాలు వినియోగదారు నిర్వచించిన డేటా రకాలను ప్రకటించడానికి కీలకమైన వాక్యనిర్మాణ అంశాలు. వివిధ రకాలైన విలువలను ఒకే తార్కిక యూనిట్గా వర్గీకరించడం ద్వారా వాటిని వ్యక్తీకరించడానికి నిర్మాణాలు మిమ్మల్ని అనుమతిస్తాయి, సంక్లిష్ట డేటా నిర్మాణాలను స్పష్టంగా మరియు సురక్షితంగా మోడల్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది.
Wave నిర్మాణం విలువ రకంగా పనిచేస్తుంది. అన్ని ఫీల్డ్లు తప్పనిసరిగా స్పష్టమైన రకాన్ని కలిగి ఉండాలి మరియు నిర్మాణ ఉదాహరణను సృష్టించేటప్పుడు అన్ని ఫీల్డ్లు తప్పనిసరిగా ప్రారంభించబడాలి. ఈ నియమాలు నిర్మాణం యొక్క స్థితి ఎల్లప్పుడూ పూర్తి మరియు ఊహాజనితంగా ఉండేలా చేస్తుంది.
స్ట్రక్చర్ డిక్లరేషన్ సింటాక్స్
struct కీవర్డ్ ఉపయోగించి నిర్మాణాలు ప్రకటించబడ్డాయి.
నిర్మాణం యొక్క పేరు PascalCaseని ఉపయోగిస్తుంది మరియు నిర్మాణం యొక్క శరీరంలో ఒకటి లేదా అంతకంటే ఎక్కువ ఫీల్డ్లను నిర్వచించవచ్చు.
ఫీల్డ్లు name: type; ఆకృతిలో ప్రకటించబడ్డాయి మరియు ప్రతి ఫీల్డ్ డిక్లరేషన్ తర్వాత సెమికోలన్ అవసరం.
struct Box {
size: i32;
weight: f32;
}
నిర్మాణాన్ని ప్రకటించేటప్పుడు, ఫీల్డ్లు సృష్టించబడిన క్రమం మెమరీ ప్లేస్మెంట్ ఆర్డర్ వలె అదే క్రమంలో ఉపయోగించబడుతుంది. నిర్మాణం లోపల ఫీల్డ్ డిక్లరేషన్లు మాత్రమే అనుమతించబడతాయి; విధులు లేదా పద్ధతులు చేర్చబడవు. చర్య తర్కం నిర్మాణం వెలుపల విడిగా నిర్వచించబడింది.
స్ట్రక్చర్ క్రియేషన్ సింటాక్స్
నిర్మాణం పేరును ఉపయోగించి నిర్మాణాలు సాహిత్య రూపంలో సృష్టించబడతాయి.
నిర్మాణ అక్షరాలు StructName { field_name: value; ... } రూపంలో వ్రాయబడ్డాయి.
var b: Box = Box {
size: 42;
weight: 10.5;
};
నిర్మాణాన్ని సృష్టించేటప్పుడు, అన్ని నిర్వచించిన ఫీల్డ్లు తప్పనిసరిగా ప్రారంభించబడాలి. ఏదైనా ఒకటి తప్పిపోయినట్లయితే, సంకలనం లోపం ఏర్పడుతుంది.
ప్రారంభ సమయంలో ఫీల్డ్ల సృష్టి క్రమం నిర్మాణ ప్రకటన క్రమానికి సరిపోలడం లేదు, కానీ ప్రతి ఫీల్డ్కు పంపబడిన విలువ రకం ఖచ్చితంగా నిర్మాణంలో నిర్వచించిన రకానికి సరిపోలాలి. Wave స్ట్రక్చర్ ఫీల్డ్ ప్రారంభ సమయంలో అవ్యక్త రకం మార్పిడిని అనుమతించదు.
స్ట్రక్చర్ ఫీల్డ్ యాక్సెస్ సింటాక్స్
నిర్మాణం యొక్క ఫీల్డ్లు డాట్ సంజ్ఞామానాన్ని ఉపయోగించి యాక్సెస్ చేయబడతాయి. ఫీల్డ్ యాక్సెస్ చదవడం మరియు వ్రాయడం రెండింటికీ ఒకే వాక్యనిర్మాణాన్ని ఉపయోగిస్తుంది.
println("Size: {}", b.size);
println("Weight: {}", b.weight);
మీరు ఉనికిలో లేని ఫీల్డ్ పేరును ఉపయోగించడానికి ప్రయత్నిస్తే, కంపైలేషన్ దశలో లోపం ఏర్పడుతుంది. నిర్మాణం విలువ రకం కాబట్టి, మొత్తం నిర్మాణాన్ని కేటాయించేటప్పుడు లేదా ఫంక్షన్ ఆర్గ్యుమెంట్గా పాస్ చేసినప్పుడు, నిర్మాణంలో ఉన్న అన్ని ఫీల్డ్లు కలిసి కాపీ చేయబడతాయి.
నిర్మాణ పద్ధతి నిర్వచనం సింటాక్స్
Wave భాష నిర ్మాణాల లోపల ప్రత్యక్ష పద్ధతులను నిర్వచించదు.
బదులుగా, నిర్మాణానికి జోడించిన పద్ధతుల సమితిని ప్రకటించడానికి proto కీవర్డ్ని ఉపయోగించండి.
proto బ్లాక్ అనేది ఒక నిర్దిష్ట నిర్మాణానికి సంబంధించిన ఫంక్షన్ల ప్రాంతం,
ఈ బ్లాక్లో నిర్వచించబడిన విధులు సంబంధిత నిర్మాణం యొక్క పద్ధతుల వలె ఉపయోగించబడతాయి.
పద్ధతి మొదటి పారామీటర్గా selfతో నిర్మాణ ఉదాహరణను ఆమోదించింది.
self అనేది నిర్మాణం యొక్క మొత్తం విలువను సూచిస్తుంది మరియు విలువను కాపీ చేయడం ద్వారా ఆమోదించబడుతుంది.
proto Box {
fun print(self) {
println("size={}, weight={}", self.size, self.weight);
}
fun added_size(self, x: i32) -> i32 {
return self.size + x;
}
}
proto బ్లాక్ని స్ట్రక్చర్ డిక్లరేషన్ వలె అదే ఫైల్లో ఉంచాల్సిన అవసరం లేదు.
బహుళ proto బ్లాక్లు ఒకే నిర్మాణం కోసం పద్ధతుల పంపిణీని నిర్వచించడానికి అనుమతిస్తాయి.
మెథడ్ కాల్లు డాట్ సంజ్ఞామానాన్ని ఉపయోగిస్తాయి మరియు సాధారణ ఫంక్షన్ కాల్ల మాదిరిగానే ప్రవర్తిస్తాయి.
b.print();
var n: i32 = b.added_size(5);
నిర్మాణాలను ఫంక్షన్ ఆర్గ్యుమెంట్లుగా ఉపయోగించడం
నిర్మాణాలను ఫంక్షన్లకు ఆర్గ్యుమెంట్లుగా పంపినప్ పుడు, అవి కాపీ-బై-వాల్యూ పద్ధతులుగా పరిగణించబడతాయి. మీరు ఫంక్షన్లోని స్ట్రక్చర్ ఫీల్డ్లను సవరించినప్పటికీ, అది కాలర్పై స్ట్రక్చర్ ఇన్స్టాన్స్ను ప్రభావితం చేయదు.
fun calc(box: Box) -> i32 {
return box.size * 2;
}
నిర్మాణాన్ని ఫంక్షన్ యొక్క రిటర్న్ విలువగా ఉపయోగించినప్పుడు అదే విలువ కాపీ చేయడం జరుగుతుంది. ఈ ప్రవర్తన నిర్మాణ మార్పుల ేని మరియు ఊహాజనిత డేటా ప్రవాహాన్ని నిర్ధారిస్తుంది.
నెస్టెడ్ స్ట్రక్ట్
Waveలో, మీరు నిర్మాణం యొక్క ఫీల్డ్ రకంగా ఇతర నిర్మాణాలను ఉపయోగించవచ్చు. నిర్మాణాలు పూర్తి రకాలైనందున, అవి ఇతర నిర్మాణాలలో స్వేచ్ఛగా గూడులో ఉంటాయి.
struct Position {
x: i32;
y: i32;
}
struct Player {
name: str;
pos: Position;
}
సమూహ నిర్మాణాల ఫీల్డ్లు సీక్వెన్షియల్ డాట్ సంజ్ఞామానాన్ని ఉపయోగించి యాక్సెస్ చేయబడతాయి.
var p: Player = Player {
name: "Alice";
pos: Position { x: 10; y: 20; };
};
println("Player X: {}", p.pos.x);
println("Player Y: {}", p.pos.y);
మీరు ఒక స్ట్రక్చర్ లిటరల్ లోపల గూడు కట్టడం ద్వారా మరొక నిర్మాణాన్ని అక్షరార్థంగా వ్రాయవచ్చు. ఈ సందర్భంలో, అన్ని ఫీల్డ్ ప్రారంభ నియమాలు సమానంగా వర్తిస్తాయి.
నిర్మాణాల శ్రేణి
శ్రేణులలో మూలకాలు రకాలుగా నిర్మాణాలను ఉపయోగించవచ్చు.
Wave యొక్క శ్రేణి సింటాక్స్ array<type, length> ఆకృతిని ఉపయోగిస్తుంది మరియు నిర్మాణ రకాన్ని కూడా అలాగే పేర్కొనవచ్చు.
var players: array<Player, 3> = [
Player { name: "A"; pos: Position { x: 1; y: 2; }; },
Player { name: "B"; pos: Position { x: 3; y: 4; }; },
Player { name: "C"; pos: Position { x: 5; y: 6; }; }
];
నిర్మాణ శ్రేణి యొక్క మూలకాలను యాక్సెస్ చేస్తున్నప్పుడు, ముందుగా శ్రేణి సూచికను ఉపయోగించండి మీరు డాట్ సంజ్ఞామానాన్ని ఉపయోగించి నిర్మాణంలోని ఫీల్డ్లను యాక్సెస ్ చేస్తారు.
println("Second Player X: {}", players[1].pos.x);
నిర్మాణాలపై ప్రాథమిక కార్యకలాపాలు సాధ్యమేనా
Wave యొక్క నిర్మాణం వినియోగదారు నిర్వచించిన రకం కాబట్టి, ఇది స్వయంచాలకంగా అంకగణితం లేదా పోలిక కార్యకలాపాలలో పాల్గొనదు.
మీకు స్ట్రక్చర్ ఈక్వాలిటీ పోలిక, సార్టింగ్, హ్యాషింగ్, న్యూమరికల్ ఆపరేషన్లు మొదలైనవి అవసరమైతే.
మీరు proto బ్లాక్ ద్వారా ప్రవర్తనను స్పష్టంగా నిర్వచించాలి.
Wave నిర్మాణాలకు అవ్యక్త ఆపరేటర్లను అందించదు,
సూత్రప్రాయంగా, అన్ని చర్యలు స్పష్టంగా నిర్వచించబడ్డాయి.