పాయింటర్

Wave Explicit Memory Type Model

Wave యొక్క పాయింటర్ డిజైన్ Wave స్పష్టమైన మెమరీ టైప్ మోడల్పై ఆధారపడి ఉంటుంది. ఈ మోడల్ పాయింటర్‌లు మరియు శ్రేణులను సింటాక్టిక్ ట్రిక్‌లు లేదా లైబ్రరీ అబ్‌స్ట్రాక్షన్‌లుగా కాకుండా, భాషా స్థాయిలో స్పష్టమైన మెమరీ రకాలుగా నిర్వచించడం లక్ష్యంగా పెట్టుకుంది.

ఈ డిజైన్ ప్రకారం, Wave పాయింటర్‌ను ptr<T> రకంగా వ్యక్తీకరిస్తుంది. ఇది ఒక నిర్దిష్ట రకం T విలువను నిల్వ చేసే మెమరీ చిరునామాను సూచించే రకం అని ఇది స్పష్టంగా వెల్లడిస్తుంది. ఈ విధానం పాయింటర్‌లను ఆపరేటర్‌లు లేదా డిక్లరేషన్ సింటాక్స్‌గా కాకుండా టైప్ సిస్టమ్‌లో భాగంగా పరిగణిస్తుంది. మెమరీ నిర్మాణాలను మరింత స్పష్టంగా మరియు స్థిరంగా వ్యక్తీకరించడానికి అనుమతిస్తుంది.

---

Waveలో, పాయింటర్ అనేది ptr<T> రకం యొక్క స్పష్టమైన రకం. చిరునామా సేకరణ కోసం & మరియు సూచన కోసం deref ఉపయోగించండి.

ప్రకటన మరియు ప్రారంభించడం

var x: i32 = 10;
var p: ptr<i32> = &x;

పాయింటర్ రకాలను గూడులో ఉంచవచ్చు.

var p1: ptr<i32> = &x;
var p2: ptr<ptr<i32>> = &p1;

వెనుక సూచన

var x: i32 = 10;
var p: ptr<i32> = &x;

println("{}", deref p); // 10
deref p = 20;
println("{}", x);       // 20

null లిటరల్ రూల్

null అనేది కానానికల్ లిటరల్. ఇది ఐడెంటిఫైయర్ కాదు మరియు వేరియబుల్ పేరుగా ఉపయోగించబడదు.

ప్రధాన నియమాలు:

• null ptr<T> లక్ష్యానికి మాత్రమే కేటాయించబడుతుంది.
• ఇది i32, bool మరియు array<...> వంటి నాన్-పాయింటర్ రకాలకు కేటాయించబడదు.
• పూర్ణాంకం అక్షరార్థంతో పాయింటర్ ప్రారంభించబడదు (0, 123, -1, మొదలైనవి). nullని స్పష్టంగా ఉపయోగించండి.

var p: ptr<i32> = null;
var arrp: ptr<array<i32, 3>> = null;

// var n: i32 = null;  // ERROR
// var b: bool = null; // ERROR

పాయింటర్ అంకగణితం

Wave కింది పాయింటర్ అంకగణితానికి మద్దతు ఇస్తుంది:

• ptr + int: GEP-ఆధారిత పాయింటర్ పురోగతి
• int + ptr: అదే ఆపరేషన్
• ptr - int: GEP-ఆధారిత పాయింటర్ వెనుకకు
• ptr - ptr: i64 బైట్ వ్యత్యాసాన్ని లెక్కించండి

పాయింట్లు:

• ptr<T> +/- n (T) పరిమాణం ఆధారంగా sizeof(T) కదులుతుంది.
• మరో మాటలో చెప్పాలంటే, ptr<i32> + 3 +12 బైట్‌కి కదులుతుంది.

var base: ptr<i32> = 0x1000 as ptr<i32>;

var p1: ptr<i32> = base + 3; // 0x1000 + 12
var p2: ptr<i32> = 2 + base; // 0x1000 + 8
var p3: ptr<i32> = base - 1; // 0x1000 - 4

var diff: i64 = p1 - base;   // 12 (byte diff)

పాయింటర్ పోలిక

పోలిక కోసం పాయింటర్లను ఉపయోగించవచ్చు.

if (p == null) { ... }
if (p != null) { ... }
if (p1 == p2) { ... }

శ్రేణులతో సంబంధం

పాయింటర్ శ్రేణి:

var a: i32 = 10;
var b: i32 = 20;
var arr: array<ptr<i32>, 2> = [&a, &b];
println("{} {}", deref arr[0], deref arr[1]);

అర్రే పాయింటర్:

var p: ptr<array<i32, 3>> = &[1, 2, 3];
if (p != null) {
    println("{}", deref p[1]);
}

భద్రతా గమనికలు

Wave ప్రస్తుతం Rust వంటి యాజమాన్యం/జీవితకాల-ఆధారిత పాయింటర్ భద్రతా నమూనాను కలిగి లేదు. కాబట్టి, null dereferences స్వయంచాలకంగా నిరోధించబడవు. deref కంటే ముందు nullని స్పష్టంగా తనిఖీ చేసే నమూనాను మేము సిఫార్సు చేస్తున్నాము.