Является ли это ОО кодом? Что должно быть в protected?

CP::Compiler* compiler = new CP::Compiler();
compiler->getLog()->writeIn(compiler->getIn());

class Compiler{
    public:
        Compiler();
        LOG::Log*           getLog();
 
    private:
        LOG::Log*           log_;
    };

class Element{          // строка таблицы лексем
    public:
        Element();
        char  getLex();
        int    getIdx();
        int     getLineNumber();
 
        void setIdx(int tiIndex);
        void setElem(int& i, int& lineNumber);
 
    private:
        char   lexeme_;
        int  lineNumber_;
        int  itIndex_;  
    };
 
    class Table{
    public:
        Table();
        Table(int size);
 
        void        addElem(Element& elem);
 
        int     getSize();
        Element*    getElem(int i);
 
        ~Table();
    private:
        int maxSize_;
        int size_;
        Element* table_;
    };

#pragma once
 
#include "errors.h"
#include "log.h"
#include "lexAnalyser.h"
#include "in.h"
#include <cwchar>
#include <iostream>
#include <string>
 
#define CP_MAX_SIZE 256
#define CP_OUT L".out"
#define CP_LOG L".log"
 
namespace LA{ class LexAnalyser; };
namespace IN{ class In; };
namespace LOG{ class Log; };
 
namespace CP{
    class Compiler{
    public:
        Compiler(int argc, _TCHAR* argv[]);
 
        wchar_t*            getInName();
        wchar_t*            getOutName();
        wchar_t*            getLogName();
        LA::LexAnalyser*    getLA();
        IN::In*             getIn();
        LOG::Log*           getLog();
 
    private:
        wchar_t inStr_[CP_MAX_SIZE];
        wchar_t outStr_[CP_MAX_SIZE];
        wchar_t logStr_[CP_MAX_SIZE];
 
        LA::LexAnalyser*    la_;
        IN::In*             in_;
        LOG::Log*           log_;
    };
};

class SomeAbstraction {
public:
    virtual int some_call();
};
 
int SomeAbstraction::some_call()
{
    /* code goes here */
}
 
class SomeAbstractionWithLogging {
public:
    virtual int some_call();
 
private:
    Log *log_actor;
};
 
int SomeAbstractionWithLogging::some_call()
{
    this->log_actor->put("some_call initiated");
    int result = SomeAbstraction::some_call();
    this->log_actor->put("some_call completed");
    return result;
}