C और C++ में वेरिएबल-लेंथ सरणी (Variable Length Arrays)

वेरिएबल-लेंथ सरणी (VLA) एक ऐसी सरणी है जिसका आकार कंपाइल टाइम के बजाय रनटाइम पर निर्धारित होता है।

C में VLA समर्थन

• C99 मानक: VLA का समर्थन करता है
• C11 मानक: VLA वैकल्पिक बना दिया गया (__STDC_NO_VLA__ मैक्रो जांचें)
• स्टैक पर आवंटित (आमतौर पर)
• स्कोप समाप्त होने पर स्वचालित रूप से मुक्त

C में VLA उदाहरण

void make_arr(int n) {
    int array[n];  // VLA - आकार रनटाइम पर ज्ञात
    // array उपयोग करें
}

int main() {
    make_arr(10);  // 10 इंटीजर्स की सरणी बनाता है
    return 0;
}

C++ में VLA समर्थन

• C++11 और पहले: **कोई VLA समर्थन नहीं**। सरणी आकार एक स्थिर-अभिव्यक्ति (constant-expression) होना चाहिए
• C++14: सरणी आकार "सरल अभिव्यक्ति" (simple expression) हो सकती है, लेकिन पूर्ण VLA नहीं
• C++20/23: अभी भी कोई मानक VLA नहीं
• GCC/Clang एक्सटेंशन के रूप में C++ में VLA समर्थन करते हैं (-pedantic चेतावनी देता है)

C++ में विकल्प

उदाहरण: C++ में डायनामिक स्ट्रक्चर (फ्लेक्सिबल सरणी सदस्य)

#include <iostream>
#include <cstring>
#include <cstdlib>

using namespace std;

struct Employee {
    int id;
    int name_length;
    int struct_size;
    char emp_name[];  // फ्लेक्सिबल सरणी सदस्य (C99, C++ में गैर-मानक एक्सटेंशन)
};

Employee* make_emp(int id, const char arr[]) {
    size_t len = strlen(arr);
    // स्ट्रक्चर + नाम के लिए मेमोरी आवंटित करें
    Employee* e = (Employee*)malloc(sizeof(Employee) + len + 1);
    e->id = id;
    e->name_length = len;
    strcpy(e->emp_name, arr);
    e->struct_size = sizeof(Employee) + len + 1;
    return e;
}

void disp_emp(Employee* e) {
    cout << "Emp Id: " << e->id << endl;
    cout << "Emp Name: " << e->emp_name << endl;
    cout << "Name Length: " << e->name_length << endl;
    cout << "Allocated: " << e->struct_size << endl;
    cout << "---------------------------------------" << endl;
}

int main() {
    Employee *e1 = make_emp(101, "Jayanta Das");
    Employee *e2 = make_emp(201, "Tushar Dey");
    
    disp_emp(e1);
    disp_emp(e2);
    
    cout << "Size of Employee: " << sizeof(Employee) << endl;
    cout << "Size of Employee pointer: " << sizeof(e1) << endl;
    
    free(e1);
    free(e2);
    return 0;
}

आउटपुट

Emp Id: 101
Emp Name: Jayanta Das
Name Length: 11
Allocated: 23
---------------------------------------
Emp Id: 201
Emp Name: Tushar Dey
Name Length: 10
Allocated: 22
---------------------------------------
Size of Employee: 12
Size of Employee pointer: 8

VLA चेतावनियां

• स्टैक ओवरफ्लो: बड़े VLAs स्टैक को समाप्त कर सकते हैं
• कोई बाउंड चेकिंग नहीं: प्रोग्रामर की जिम्मेदारी
• पोर्टेबिलिटी: C11+ में वैकल्पिक, C++ में मानक नहीं
• प्रदर्शन: छोटी सरणियों के लिए तेज़, बड़ी के लिए malloc बेहतर

सर्वोत्तम अभ्यास

• C में: छोटी, स्कोप-सीमित सरणियों के लिए VLA उपयोग करें; बड़ी/दीर्घकालिक के लिए malloc
• C++ में: std::vector प्राथमिकता दें
• हमेशा आवंटन सफलता जांचें