Функции и переменные не являются членами класса

#pragma once
 
 
#include <iostream>
#include <string>
#include "Country.h"
 
 
using namespace std;
 
class hardware {
 
private:
 
 
    char* name;
    string model;
    double price;
    Country country;
    static int count;
 
 
    void set_name(const char* name);
 
protected:
    virtual void display_header()const;
    virtual void display_info()const;
public:
    //������������
    hardware(const char* name1, string model1, double price1, Country country1);
    hardware(const hardware& other);
    bool operator<(const hardware& other) const {
        return this->price < other.country;
    }
 
    ~hardware();
 
    bool operator==(Country country) const {
        return country == this->country;
    }
 
    //����������
 
    //������ 
    virtual void display()const;
 
    virtual const char* getName() const;
    virtual string getModel()const;
    virtual double getPrice()const;
    virtual Country getCountry()const;
    static int getCount();
 
};

#include <iostream>
 
 
#include "Hardware.h"
 
 
using namespace std;
 
//������������
int hardware::count = 0;
 
void hardware::set_name(const char* name1) {
    delete[] name;
    int b = strlen(name1) + 1;
    name = new char[b];
    strcpy_s(name, b, name1);
}
 
hardware::hardware(const char* name1, string model1, double price1, Country country1) {
    set_name(name1);
    model = model1;
    price = price1;
    country = country1;
    //count++;
}
 
hardware::hardware(const hardware& other)
 
    :hardware(other.name, other.model, other.price, other.country) {
 
}
 
//����������
hardware::~hardware() {
    count--;
    delete[] name;
}
 
 
void hardware::display_header() const
{
    cout << "-------------------------------------------" << endl;
    cout << "Hardware" << endl;
    cout << "-------------------------------------------" << endl;
}
 
void hardware::display_info() const
{
}
 
//������
void hardware::display()const {
    display_header();
    cout << "Name: " << name << endl;
    cout << "Model: " << model << endl;
    cout << "Price: $" << price << endl;
    cout << "Country: ";
    switch (country) {
    case USA:
        cout << "USA" << endl;
        break;
    case China:
        cout << "China" << endl;
        break;
    case Russia:
        cout << "Russia" << endl;
        break;
    case Japan:
        cout << "Japan" << endl;
        break;
    case Germany:
        cout << "Germany" << endl;
        break;
    }
 
    display_info();
 
}
 
 
 
const char* hardware::getName()const {
    return name;
}
 
string hardware::getModel()const {
    return model;
}
 
double hardware::getPrice()const {
    return price;
}
 
Country hardware::getCountry()const {
    return country;
}
 
int hardware::getCount() {
    return count;
}

#pragma once
#include <iostream>
#include <string>
class Software {
private:
    string SystemSoftware;
    string OperatingSystem;
protected:
    virtual void display_header()const;
    virtual void display_info()const;
public:
    Software(string SystemSoftware1, string OperatingSystem1) {
        SystemSoftware = SystemSoftware1;
        OperatingSystem = OperatingSystem1;
    };
    Software(const Software& other) : Software(other.SystemSoftware, other.OperatingSystem)
    {
    };
    ~Software();
    virtual string Is_SystemOperating()const;
    virtual string get_OperatingSystem()const;
    virtual void display()const;
};

#include "Software.h"
using namespace std;
 
void Software::display_header() const
{
    cout << "-------------------------------------------" << endl;
    cout << "Software" << endl;
    cout << "-------------------------------------------" << endl;
}
 
void Software::display_info() const
{
}
 
void Software::display() const
{
    display_header();
    cout << "Is system software exist?: " << SystemSoftware;
    cout << "Which one operating system?(if exist): " << OperatingSystem;
    display_info();
}
 
 
Software::~Software()
{
}
 
string Software::Is_SystemOperating() const
{
    return SystemSoftware;
}
 
string Software::get_OperatingSystem() const
{
    return OperatingSystem;
}

#pragma once
#include "hardware.h"
#include "Software.h"
class IODevice :
    public hardware, public Software
{
private:
    string IODevice_function;
    string IODevice_type;
 
 
protected:
    virtual void display_header()const override;
    virtual void display_info()const override;
public:
    IODevice(const char* name1, string model1, double price1, Country country1, string SystemSoftware1, string OperatingSystem1, string IODevice_function1, string IODevice_type1) :hardware(name1, model1, price1, country1), Software(SystemSoftware1, OperatingSystem1) {
        IODevice_function = IODevice_function1;
        IODevice_type = IODevice_type1;
    };
    IODevice(const IODevice& other) :hardware(other), Software(other) {
        IODevice_function = other.IODevice_function;
        IODevice_type = other.IODevice_type;
    };
 
 
    virtual void display()const override;
    string get_IODevice_function()const;
    string get_IODevice_type()const;
 
};

#include "IODevice.h"
 
void IODevice::display()const {
 
    hardware::display();
    Software::display();
 
}
 
string IODevice::get_IODevice_type()const
{
    return IODevice_type;
}
 
string IODevice::get_IODevice_function()const
{
    return IODevice_function;
}
void IODevice::display_header() const
{
    cout << "------------------------------------" << endl;
    cout << "IODevice" << endl;
    cout << "-------------------------------------------" << endl;
}
 
void IODevice::display_info() const
{
    cout << "Input / output: " << IODevice_type << "\n";
    cout << "Function of hardware: " << IODevice_function << " " << "\n";
}