Ошибка argument of type "CGroup *" is incompatible with parameter of type "CGroup *"

//класс CBase (база)
private:
    vector <CCourse> _courses;
    vector <CGroup*> _groups;
    vector <CStudent*> _students;
 
//класс CCourse (курс)
private:
    vector <CGroup*> _groups;
 
//класс CGroup (группа)
private:
    vector <CStudent*> _students;

//формирование данных
CGroup* newGroup = new CGroup(sName, course, code);
        _courses[course - 1].addGroup(newGroup);

void CCourse::addGroup(CGroup *group) {
    _groups.push_back(group);
}

_courses[course - 1]->addGroup(newGroup);

#include <iostream>
#include <fstream>
#include <vector>
#include <string>
 
using namespace std;

#pragma once
#include "including.h"
 
class CInterface
{
public:
    CInterface(void);
    ~CInterface(void);
};

#include "including.h"
 
class CStudent
{
private:
    int _code;
    int _groupCode;
    string _name;
    struct {
        int _year;
        int _month;
        int _day;
    } _bornDate;
    string _status;
    vector <int> _marks;
 
public:
    CStudent();
    ~CStudent();
};

#include "including.h"
#include "Student.h"
 
class CGroup
{
private:
    string _name;
    int _course;
    int _code;
    vector <CStudent*> _students;
 
public:
    string getName();
    int getCode();
    int getCourse();
    void addStudent(CStudent *student);
    vector <CStudent*> getStudents();
 
public:
    CGroup();
    CGroup(string name, int course, int code);
    ~CGroup();
};

#include "including.h"
#include "Group.h"
 
class CCourse
{
private:
    int _number;
    vector <CGroup*> _groups;
 
public:
    int getNumer();
    void addGroup(CGroup* group);
    vector <CGroup*> getGroups();
 
public:
    CCourse(void);
    CCourse(int number);
    ~CCourse(void);
};

#include "including.h"
#include "Course.h"
#include "Group.h"
 
class CBase
{
private:
    vector <CCourse> _courses;
    vector <CGroup*> _groups;
    vector <CStudent*> _students;
 
    string _groupsPath;
    string _studentsPath;
    string _marksPath;
 
public:
    CBase(void);
    ~CBase(void);
 
    void readFiles();
};

#include "including.h"
#include "Base.h"
 
void main(){
setlocale(LC_ALL, "russian");
CBase pBase;
pBase.readFiles();
cin.get();
}

#include "Interface.h"
 
 
CInterface::CInterface(void)
{
}
 
 
CInterface::~CInterface(void)
{
}

#include "Student.h"
 
 
CStudent::CStudent(void)
{
}
 
 
CStudent::~CStudent(void)
{
}

#include "Group.h"
 
 
CGroup::CGroup(void) {
    _name = "undefined";
    _course = 0;
    _code = 0;
}
 
CGroup::CGroup(string name, int course, int code) {
    _name = name;
    _course = course;
    _code = code;
}
 
CGroup::~CGroup(void) {
    _students.clear();
}
 
string CGroup::getName(){
    return _name;
}
 
int CGroup::getCode(){
    return _code;
}
 
void CGroup::addStudent(CStudent *student) {
    _students.push_back(student);
}
 
vector <CStudent*> CGroup::getStudents(){
    return _students;
}

#include "Course.h"
 
CCourse::CCourse(void) {
    _number = 1;
}
 
CCourse::CCourse(int number) {
    _number = number;
}
 
CCourse::~CCourse(void) {
    _groups.clear();
}
 
int CCourse::getNumer() {
    return _number;
}
 
void CCourse::addGroup(CGroup *group) {
    _groups.push_back(group);
}
 
vector <CGroup*> CCourse::getGroups(){
    return _groups;
}

#include "Base.h"
#include <Windows.h>
 
CBase::CBase(void){
    _groupsPath = "groups.txt";
    _studentsPath = "students.txt";
    _marksPath = "marks.txt";
}
 
 
CBase::~CBase(void)
{
}
 
void CBase::readFiles(){
    fstream file;
    file.open(_groupsPath, ios::in);
    if (!file.is_open()){
        cout << "Произошла ошибка при чтении файла групп!" << endl;
        return;
    }
    char tmp[256];
    file.getline(tmp,256);
    while (!file.eof()){
        file.getline(tmp,256);
        string tmpStr = tmp;
        string sIndex;
        string sName;
        string sCourse;
        int ind;
        ind = tmpStr.find(" | ");
        sIndex = tmpStr.substr(0,ind);
        tmpStr.erase(0, ind + 3);
        ind = tmpStr.find(" | ");
        sName = tmpStr.substr(0,ind);
        tmpStr.erase(0, ind + 3);
        sCourse = tmpStr.substr(0,ind);
        int code = atoi(sIndex.data());
        int course = atoi(sCourse.data());
        
        if (_courses.size() < course){
            for (int i = _courses.size(); i < course; i++){
                _courses.push_back(CCourse(i + 1));
            }
        }
 
        CGroup* newGroup = new CGroup(sName, course, code);
        _courses[course - 1].addGroup(newGroup);
 
    }
    
    for (int i = 0; i < _courses.size(); i++){
        cout << "Курс " << i + 1 << ":" << endl;
        cout << "\tГрупп на курсе: " << _courses[i].getGroups().size() << endl;
        for (int j = 0; j < _courses[i].getGroups().size(); j++){
            cout << '\t' << _courses[i].getGroups()[j] -> getName() << endl;
        }
        cout << endl;
    }
    file.close();
}

#pragma once