Constructor that Dynamically allocates an array

This is more or less what std::vector does, though that one is implemented with significantly greater generality in mind, so it's a bit hard for a newcomer to read the source of any library implementation (especially given the usually nightmarish naming conventions used in standard library code).

Here's baby's first dynamic array:

class MyArray
{
  float * buf;
  std::size_t size;

public:
  explicit MyArray(std::size_t s) : buf(new float[s]), size(s) { }
  ~MyArray() { delete[] buf; }

  // Copying and reassigning is tricky! We disallow it for now.
  MyArray(MyArray const &) = delete;
  MyArray & operator=(MyArray const &) = delete;

  std::size_t size() const { return size; }
  float & operator[](std::size_t i) { return buf[i]; }
  float const & operator[](std::size_t i)  const { return buf[i]; }
};

This is exception-safe: the only time an exception could happen is in the initializer list of the constructor, and there is only one such occasion (new). Should an exception happen, nothing will be leaked, since nothing else has been allocated at that point.

Usage:

MyArray a(20);
a[4] = 6.3;

A more advanced version would include a resize() feature; for that, you'll have to allocate and copy (say):

void resize(std::size_t n)
{
  float * tmp = new float[n];
  std::copy(buf, buf + std::min(size, n), tmp); // I assume this doesn't throw

  delete[] buf;

  buf = tmp;
  size = n;
}

Once you understand what the assignment operator is supposed to do, you can use an idea very similar to that of resize() to assign one MyArray to another.

struct Array_holder
{
    float* arr;

    Array_holder(size_t size):
    arr(new float[size])
    {}

    ~Array_holder()
    { delete[] arr; }

    float get(size_t i) const
    { return arr[i]; }
};

writing this rather simple code I made 2 rude mistakes:

1) I forgot to free memory 2) I haven't implemented copy constructor and assignment operator that according to rule of 3 are required if class have destructor.

This is good example why working with dynamic memory is complicated and dangerous. Compare with following example:

#include <vector>

struct Array_holder
{
    std::vector<float> arr;

    Array_holder(size_t size):
    arr(size)
    {}

    float get(size_t i) const
    { return arr.at(i); }
};

This example is shorter, simpler, more readable, less error-prone and more reliable in usage.

First, because you're using C++, you should just be using a std::vector.

Second:

class DynamicArray {
    float* array;
public:
    DynamicArray( int size ) { array = new float[ size ]; }
    ~DynamicArray( void ) { delete[] array; }
    float* get( void ) const { return array; }
};