Ugrás a tartalomhoz

variable-length array

A Wikiszótárból, a nyitott szótárból

Angol


Főnév

variable-length array (tsz. variable-length arrays)

  1. (informatika) A Variable-Length Array (VLA) egy olyan tömb, amelynek mérete futásidőben határozható meg, ellentétben a normál C++ statikus tömbökkel, amelyek mérete fordítási időben rögzített. A C++ nem támogatja natívan a VLA-kat, szemben a C-vel, ahol bizonyos fordítók és szabványok engedélyezik. Ehelyett dinamikus memóriafoglalást használhatunk a new, std::vector, vagy a std::unique_ptr segítségével.


1. Statikus tömbök és korlátjaik

A C++ nyelvben egy normál statikus tömb mérete fordítási időben fix:

int arr[10];  // Mindig 10 elemű

Ez azt jelenti, hogy nem lehet futásidőben módosítani a méretét, ami sok esetben korlátozó tényező lehet.


2. C-féle Variable-Length Array (VLA)

A C99 szabvány bevezette a VLA-kat, ahol a méretet futásidőben lehet meghatározni:

#include <stdio.h>

void func(int n) {
    int arr[n];  // VLA C-ben (de nem szabványos C++)
    for (int i = 0; i < n; ++i) {
        arr[i] = i * 2;
    }
}

Ez a megoldás azonban nem működik C++-ban, mert a nyelvtervezők nem vették át a VLA-k támogatását.


3. Alternatívák C++-ban

Mivel a natív VLA-k nem támogatottak C++-ban, több alternatív megoldás létezik.

3.1. Dinamikus memóriafoglalás (new és delete)

A new operátorral dinamikusan foglalhatunk memóriát futásidőben:

#include <iostream>

void func(int n) {
    int* arr = new int[n];  // Dinamikusan foglalt tömb
    for (int i = 0; i < n; ++i) {
        arr[i] = i * 2;
    }

    delete[] arr;  // Fontos felszabadítani a memóriát!
}

Ez működik, de hátránya, hogy manuálisan kell kezelni a memóriafelszabadítást.


3.2. std::vector – A legjobb megoldás

A std::vector egy dinamikus tömb, amely automatikusan kezeli a memóriafoglalást és felszabadítást:

#include <vector>
#include <iostream>

void func(int n) {
    std::vector<int> arr(n);  // Dinamikus méretű tömb
    for (int i = 0; i < n; ++i) {
        arr[i] = i * 2;
    }
}

A std::vector sokkal biztonságosabb és kényelmesebb, mint a nyers mutatók.


3.3. std::unique_ptr használata

Ha egyedi tulajdonú dinamikus tömböt szeretnénk, akkor a std::unique_ptr jó választás lehet:

#include <memory>
#include <iostream>

void func(int n) {
    std::unique_ptr<int[]> arr(new int[n]);
    for (int i = 0; i < n; ++i) {
        arr[i] = i * 2;
    }
}

Ez automatikusan felszabadítja a memóriát, amikor az arr kilép a hatóköréből.


4. Összegzés

  • A Variable-Length Array (VLA) nem része a C++ szabványnak.
  • Alternatívák: new, std::vector, std::unique_ptr.
  • Ajánlott megoldás: std::vector, mert biztonságos és könnyen használható.

A C++-ban a dinamikus tömbök kezelése kényelmes és hatékony, ha megfelelő eszközöket használunk. 🚀

További információk

A lap eredeti címe: „https://hu.wiktionary.org/w/index.php?title=variable-length_array&oldid=3490462”