массивы как поле класса

[Sergius X]

Сообщение от Perchik71

Sergius X,

class CClass {
  private:
    int array[9];
  public:
    getItemAt(const int id) { return array[id]; }
    setItemAt(const int id, const int value) { array[id] = value; }
    __declspec(property(get=getItemAt, put=setItemAt)) int Item[const int id];
};

методы доступа в private пишутся. И это не динамический массив. Это не то что нужно

[Perchik71]

методы доступа в private пишутся

если в delphi тоже, то и bcb. в visual нет.

И это не динамический массив

Я привёл пример тупо массива, сделать динамически нетрудно.

[_Bers]

Сообщение от Igor95

Да, я понимаю, и Вы абсолютно правы. Просто автор хотел собственную реализацию.

Автору стоит пожелать научиться грамотно формулировать свои мысли.
Не понятно, чего он хочет.

[Пепел Феникса]

методы доступа в private пишутся.

с чего это вдруг они обязаны быть приватными?
просто принято их инкапсулировать.

[Sergius X]

Сообщение от _Bers

Не понятно, чего он хочет.

Я же привел пример своей попытки, мне нужна подобная конструкция, что бы я мог работать с этим массивом, как с обычным полем

Сообщение от Perchik71

Я привёл пример тупо массива, сделать динамически нетрудно.

В том то и трудность, что я не могу собрать все в кучу, что бы это корректно работало для динамического массива

[Nuklon]

Вот держи, я тут накидал простенький костыль.

#include <stdio.h>


// Аллокатор
template<typename T>
struct myAlloc {

    static T*  get_alloc(size_t n) {
          T* p;
          try {
             p = new T[n];
          } catch(...) {
             return NULL;
          }
          return p;
    }

    static void dispose(T*& p) {
         if(p != NULL)
              delete[] p;
         p = NULL;
    }

    // память выделяется блоками, можешь указать оптимальный собственный размер 
    static size_t get_block(void) {
          return 32u;
    }
};







// динамический массив
template<typename T, typename Alloc = myAlloc<T> >
class  myArray {
private:
     T*      p;
     size_t  n;
     size_t  m;
public:
     myArray(void) : p(NULL), n(0u), m(Alloc::get_block()){}

     explicit myArray(const myArray& o) 
       : p(NULL), n(0u), m(Alloc::get_block()) {
          this->Copy(o);
     }

     ~myArray() {
          this->Clear();
      }


     // добавление
     void  Add(const T& v) {
          if(p == NULL) {
              if((p = Alloc::get_alloc(m)) == NULL)
                   return;
          }

          if(n >= m) {
              m   += Alloc::get_block();
              T* t = Alloc::get_alloc(m);
              if(t == NULL)
                   return;

              for(size_t i = 0u; i < n; i++)
                   t[i] = p[i];
              Alloc::dispose(p);
              p = t;
           } 
           p[n++] = v;
     }


     // копирование 
    void Copy(const myArray& o) {
        if(o.Empty()) 
             return;

        if(o.GetSize() > n) {
            this->Clear();
            if((p = Alloc::get_alloc(o.GetSize())) == NULL)
                 return;
        }
        for(size_t i = 0u; i < o.GetSize(); i++)
             p[i] = o[i];
        n = o.GetSize();
    }


    // удаление отрезка с first до last позиции за O(n)
    void  Delete(size_t f, size_t l) {
        if((p == NULL) || (! n) || (l > n))
             return;

        size_t c = l - f;
        for(size_t k = f; k < (n - c); k++) 
             p[k] = p[k + c];
        n -= c;
    }


    inline T& operator [] (size_t i) {
        return p[i];
    }


    inline T& operator [] (size_t i) const {
        return p[i];
    }


    myArray& operator = (const myArray& o) {
        this->Copy(o);
        return *this;
    }

    // размер
    size_t GetSize(void) const {
        return n;
    }


    bool Empty(void) const {
        return ((p == NULL) || (! n));
    }

    // удаление массива из памяти
    void Clear(void) {
        if(p != NULL)
             Alloc::dispose(p);
        n = 0;
        m = Alloc::get_block();
     }

};






// ...
int  main(void) {

        myArray<int> arr;

	for(int j = 1; j < 30; j++)
		arr.Add(j);

	// удалить элементы с 10-ой по 20-ой позиции
	arr.Delete(9, 20);

	// вывести 1-ый и последний элемент
	printf("first = %d\tlast = %d\n", arr[0], arr[arr.GetSize() - 1]);


	myArray<int> b(arr);
	for(size_t i = 0u; i < b.GetSize(); i++)
		printf("%d\n", b[i]);

	b.Clear();
	arr.Clear();
	return 0;
}

Проверка кода: http://codepad.org/cR9gdgHk

[Пепел Феникса]

примените вектор, он за вас всю память выделит.