I would say:

// student.h
class Student
{
public:
    // If you can, don't use numbers: 
    // you have a 3 on the variable,
    // a 3 on the function, etc.
    // Use a #define on C or a static const on C++
    static const int SIZE= 3;
    // You can also use it outside the class as Student::SIZE

public:
    void SetDaysToCompleteCourse(int* daysToCompleteCourse);

    // The consts are for "correctness"
    // const int* means "don't modify this data" (you have a setter for that)
    // the second const means: this function doesn't modify the student
    // whithout the const, student.GetDaysToCompleteCourse()[100]= 1 is 
    // "legal" C++ to the eyes of the compiler
    const int* GetDaysToCompleteCourse() const; // Ditto @ above comment.

    Student()
    {
        // Always initialize variables
        for (int i= 0; i < SIZE; i++) {
            daysToCompleteCourse[i]= 0;
        }
    }

private:
    int daysToCompleteCourse[SIZE];
    // On GCC, you can do
    //int daysToCompleteCourse[SIZE]{};
    // Which will allow you not to specify it on the constructor
};

// student.cpp
void Student::SetDaysToCompleteCourse(int* newDaysToCompleteCourse) 
{
    // It's not wrong, just that
    // this->daysToCompleteCourse[0] = daysToCompleteCourse[0];
    // use another name like newDaysToCompleteCourse and then you can suppress this->
    // And use a for loop
    for (int i= 0; i < SIZE; i++) {
        daysToCompleteCourse[i]= newDaysToCompleteCourse[i];
    }
}

const int* Student::GetDaysToCompleteCourse() const
{
    return daysToCompleteCourse;
}


// main.cpp
#include <iostream>

std::ostream& operator<<(std::ostream& stream, const Student& student)
{
    const int* toShow= student.GetDaysToCompleteCourse();
    for (int i= 0; i < Student::SIZE; i++) {
        stream << toShow[i] << ' ';
    }
    return stream;
}

int main()
{
    Student student;
    int daysToCompleteCourse[3] = { 1, 2, 3 };
    // You don't need this
    //int* ptr = daysToCompleteCourse;
    //student.SetDaysToCompleteCourse(ptr);
    //You can just do:
    student.SetDaysToCompleteCourse(daysToCompleteCourse);

    // On C++ int* is "a pointer to an int"
    // It doesn't specify how many of them
    // Arrays are represented just by the pointer to the first element
    // It's the FASTEST and CHEAPEST way... but you need the SIZE
    const int* toShow= student.GetDaysToCompleteCourse();
    for (int i= 0; i < Student::SIZE; i++) {
        std::cout << toShow[i] << ' ';
        // Also works:
        //std::cout << student.GetDaysToCompleteCourse()[i] << ' ';
    }
    std::cout << std::endl;

    // Or you can do: (because we defined operator<< for a ostream and a Student)
    std::cout << student << std::endl;
}

You can check out it live here: https://ideone.com/DeJ2Nt

string name[];

This is not an array, it is a pointer. Use vectors instead:

#include <vector>
class planet: public body
{
private:
  vector<string> name;
  vector<string> star;
public:
  void nameSetter (const vector<string> &h_name)
  {
      name = h_name;
  }
};

You cannot pass arrays by value into and out of functions. But there's various options.

(1) Use a std::array<type, size>

#include <array>

    typedef std::array<int, m_cols> row_type;
    typedef std::array<row_type, m_rows> array_type;
    array_type& getBoard() {return m_board;}
    const array_type& getBoard() const {return m_board;}
private:
    array_type m_board;

(2) Use the correct pointer type.

    int *getBoard() {return m_board;}
    const int *getBoard() const {return m_board;}
private:
    int m_board[m_rows][m_cols];

An int[][] has no pointers involved. It isn't a pointer to an array of pointers to arrays of integers, it's an array of an array of integers.

//row 1               //row2
[[int][int][int][int]][[int][int][int][int]]

Which means one int* points to all of them. To get to a row offset, you'd do something like this:

int& array_offset(int* array, int numcols, int rowoffset, int coloffset)
{return array[numcols*rowoffset+coloffset];}

int& offset2_3 = array_offset(obj.getBoard(), obj.m_cols, 2, 3);

A multi-dimensional array is also a 1-dimensional array: int[a][b][c] is really just int[a*b*c], so the problem boils down to, how do you provide access safely? Simply like this:

public class Foo {
    private int[] array;

    public Foo(int[] array) {
        this.array = Arrays.copyOf(array, array.length);
    }

    /** @return a copy of the array */
    public int[] getArray() {
        return Arrays.copyOf(array, array.length);
    }
}

That's it.

Callers have a safe copy of the array and can use it in the full normal way arrays are used. No need for delegator methods.