Как правильно передать указатель this в сторонний класс?

// Field.cpp
 
#include "Field.hpp"
 
Field::Field(void) {
    attacked = 0;
    is_free = true;
}
 
StatusBool Field::get_if_attacked(void) const {
    return attacked;
}
void Field::inc_attacked(void) {
    attacked++;
}
void Field::dec_attacked(void) {
    if (!attacked) throw EPField("The parameter \"attacked\" can\'t be less than zero", this);
    attacked--;
}
 
StatusBool Field::get_if_free(void) const {
    return is_free;
}
void Field::release_field(void) {
    if (is_free == true) throw EPField("The field is already free", this);
    is_free = true;
}
void Field::take_field(void) {
    if (is_free == false) throw EPField("The field is already taken", this);
    is_free = false;
}

// EPField.hpp
 
#ifndef EPFIELD_HPP
#define EPFIELD_HPP
 
#include "ErrorProcessing.hpp"
#include "Field.hpp"
 
class EPField : public ErrorProcessing {
    public:
        EPField(ErrorText ex_error_text, Field *ex_error_field);
 
    private:
        Field *error_field;
 
        void print_variables() const;
};
 
#endif // EPFIELD_HPP

// EPField.cpp
 
#include "EPField.hpp"
 
EPField::EPField(ErrorText ex_error_text, Field *ex_error_field)
: ErrorProcessing(ex_error_text), error_field(ex_error_field) {}
 
void EPField::print_variables() const {
    std::cout << "Variables:" << std::endl
              << "attacked = " << error_field->attacked << std::endl
              << "is_free = " << error_field->is_free << std::endl;
}

// ErrorProcessing.hpp
 
#include <string>
#include <iostream>
#include <cstdlib>
 
#ifndef ERRORPROCESSING_HPP
#define ERRORPROCESSING_HPP
 
typedef std::string ErrorText;
 
class ErrorProcessing {
    public:
        ErrorProcessing(ErrorText ex_error_text);
        virtual ~ErrorProcessing();
 
        void print_report() const;
 
    private:
        ErrorText error_text;
 
        virtual void print_variables() const;
        void print_error_text() const;
};
 
#endif // ERRORPROCESSING_HPP

// ErrorProcessing.cpp
 
#include "ErrorProcessing.hpp"
 
using std::cout;
using std::endl;
 
ErrorProcessing::ErrorProcessing(ErrorText ex_error_text)
: error_text(ex_error_text) {
    cout << endl << "***ERROR DETECTED!!!***" << endl;
}
ErrorProcessing::~ErrorProcessing(void) {
    cout << "Press enter to exit..." << endl;
    std::cin.get();
    exit(1);
}
 
void ErrorProcessing::print_report() const {
    cout << endl;
    print_error_text();
    cout << endl;
    print_variables();
    cout << endl;
}
 
void ErrorProcessing::print_variables(void) const {
    cout << "Variables:" << endl
         << "<NO VARIABLES>" << endl;
}
void ErrorProcessing::print_error_text(void) const {
    cout << "Error: " << error_text << endl;
}

#pragma once

#ifndef ...
#define ...
#endif

// Field.hpp
 
#ifndef FIELD_HPP
#define FIELD_HPP
 
#include "EPField.hpp"
 
typedef bool StatusBool;
 
class Field {
    public:
        Field();
 
        StatusBool get_if_attacked() const;
        void inc_attacked();
        void dec_attacked();
 
        StatusBool get_if_free() const;
        void release_field();
        void take_field();
 
    private:
        unsigned int attacked;
        StatusBool is_free;
 
        friend class EPField;
};
 
#endif // FIELD_HPP

#include "..."

#include "Field.hpp"

#include "EPField.hpp"

class EPField : public ErrorProcessing {
    public:
        EPField(ErrorText ex_error_text, Field *ex_error_field);
        ...
};
 
 
class Field {
    public:
        Field();
        ...
 
        friend class EPField;
};

#include

#include "Field.hpp"
 
 
int main() {
...
return 0;
}

#include "EPField.hpp"
 
class Field {
    public:
        Field();
        ...
 
        friend class EPField;
};
 
int main() {
...
return 0;
}

class EPField : public ErrorProcessing {
    public:
        EPField(ErrorText ex_error_text, Field *ex_error_field);
        ...
};
 
 
class Field {
    public:
        Field();
        ...
 
        friend class EPField;
};
 
int main() {
...
return 0;
}

#ifndef ...
#define ...
#endif

EPField(ErrorText ex_error_text, Field *ex_error_field);

// EPField.hpp
 
#ifndef EPFIELD_HPP
#define EPFIELD_HPP
 
class Field; // вот эта строка
 
#include "ErrorProcessing.hpp"
#include "Field.hpp"
 
class EPField : public ErrorProcessing {
    public:
        EPField(ErrorText ex_error_text, Field* ex_error_field);
 
    private:
        void print_variables() const;
 
        Field *error_field;
};