Figuring out an struct in C++ - c++

Question

I am doing the "Game of life" as an assignment for the college, the tutor has given to us part of the code, but I am having problem for understand two parts.
First:
grid(int scale) : scale_(scale), width_(problem_definition::width(scale)), height_(problem_definition::height(scale)), data_(new problem_definition::data_type[width_*height_])
Until I can understand is the moment that he requests for the memory which is used for the grid for the simulation. However, I can not grasp the syntax beyond the new. why are those brackets with an empty space? what does mean the colon after grid (int scale)?
Second:
void initialize()
{
for (std::size_t y = 0; y < height_; ++y)
{
for (std::size_t x = 0; x < width_; ++x)
{
at(x,y) = problem_definition::initialize(x, y, scale_);
}
}
}
what is this "at()" inside the second for loop?
I would appreciate any insight here is the full struct definition:
struct grid
{
grid(int scale) : scale_(scale), width_(problem_definition::width(scale)), height_(problem_definition::height(scale)), data_(new problem_definition::data_type[width_*height_])
{
}
void initialize()
{
for (std::size_t y = 0; y < height_; ++y)
{
for (std::size_t x = 0; x < width_; ++x)
{
at(x,y) = problem_definition::initialize(x, y, scale_);
}
}
}
problem_definition::data_type at(std::size_t x, std::size_t y, int dx, int dy)
{
if (dx<0 && -dx>x) return problem_definition::out_of_bounds_value();
if (dy<0 && -dy>y) return problem_definition::out_of_bounds_value();
if (x + dx >= width_) return problem_definition::out_of_bounds_value();
if (y + dy >= height_) return problem_definition::out_of_bounds_value();
return at((int)x + dx, (int)y + dy);
}
problem_definition::data_type& at(std::size_t x, std::size_t y)
{
return data_[x + y*width_];
}
void swap(grid& other)
{
std::swap(scale_, other.scale_);
std::swap(width_, other.width_);
std::swap(height_, other.height_);
std::swap(data_, other.data_);
}
void print(std::ostream& str)
{
for (std::size_t y = 0; y < height_; ++y)
{
for (std::size_t x = 0; x < width_; ++x)
{
str << at(x, y);
}
str << std::endl;
}
}
private:
int scale_;
std::size_t width_;
std::size_t height_;
std::unique_ptr<problem_definition::data_type[]> data_;
};

Answer 1

Let's add some white space to the first line to make it easier to read:
grid(int scale) : scale_(scale),
width_(problem_definition::width(scale)),
height_(problem_definition::height(scale)),
data_(new problem_definition::data_type[width_*height_])
Now we can easily see the colon (a : is a colon, a ; is a semicolon) defines an initialiser list which takes a series of var(value) pairs and assigns each value to each var.
I don't see any "brackets with an empty space" so can't answer that. But beyond new is just a standard array type of the form: element_type[length]. The element type is problem_definition::data_type and the array is of length width_ times height_.
Finally, at() is just a function call that returns a reference. If you study the function definition:
problem_definition::data_type& at(std::size_t x, std::size_t y)
{
return data_[x + y*width_];
}
then you can see the line with the call to at(), via the magic of references, is the same as the following:
data_[x + y*width_] = problem_definition::initialize(x, y, scale_);