Ошибка binary '=' : no operator found which takes a right-hand operand of type

#pragma once
#include <iostream>
#include <queue>
#include <vector>
#include "printDevice.h"
using namespace std;
class Advertising
{
    private:
    queue<printDevice> advers;
public:
    Advertising();
    void addReklama(printDevice);
    void removeReklama();
    vector<printDevice> getAdvertising(); //Когда убераю эту строку и реализацию в cpp программа запускается
    ~Advertising();
};

#include "Advertising.h"
 
 Advertising::Advertising()
{
}
 
 
void Advertising::addReklama(printDevice adver)
{
    advers.push(adver);
}
 
void Advertising::removeReklama()
{
    advers.pop();
}
vector<printDevice> Advertising::getAdvertising() // Реализация
{
    vector<printDevice> vectorAdvertising;
    queue<printDevice> savedAdvertising = advers;
    while (!advers.empty()) {
        vectorAdvertising.push_back(advers.front());
        advers.pop();
    }
    advers = savedAdvertising;
    return vectorAdvertising;
}
 
Advertising::~Advertising()
{
}

#include "Device.h"
#include<istream>
#include<iostream>
#include<string>
#include <algorithm>
 using namespace std;
 #pragma once
class printDevice : public Device
{
 
protected:
    
    int diagonal;
    std::string quality;
 
public:
    printDevice(string str = "0", int x = 0, int y = 0, int dia = 0, string qua = "0") : Device(str, x, y)
    {
        this -> diagonal = dia;
        this -> quality  = qua;
    }
    
    printDevice(const printDevice&);
    printDevice & operator=(printDevice &dev);
   void operator () (const char*, int, int, int,  const char*);
    friend std::istream & operator>>(std::istream &is, printDevice&);
    friend std::ostream & operator << (std::ostream&, printDevice&);
    ~printDevice() {}
};

#include "printDevice.h"
#include <fstream>
#include<istream>
#include<iostream>
#include<string>
#include <iostream>
#include <algorithm>
 
 printDevice & printDevice::operator=(printDevice &dev)
{
    if (this != &dev) {
        this ->interface=dev.interface;
        this ->power=dev.power;
        this ->weight = dev.weight;
        this -> diagonal=dev.diagonal;
    this -> quality=dev.quality;
    }
    return dev;
}
 printDevice::printDevice(const printDevice& print)
{
    this ->interface=print.interface;
        this ->power=print.power;
        this ->weight = print.weight;
        this -> diagonal=print.diagonal;
    this -> quality=print.quality;
}
void printDevice::operator () (const char *str, int x, int y, int dia, const char *qual)
{
    this -> interface = str;
    this -> power     = x;
    this -> weight    = y;
    this -> diagonal  = dia;
    this -> quality   = qual;
}
 std::istream & operator>>(std::istream &is, printDevice &dev)
{
   
        cout<<"Enter Interface: ";
        cin>>dev.interface;
        cout<<"Enter power: ";
        cin>>dev.power;
        cout<<"Enter weight: ";
        cin>>dev.weight;
        cout<<"Enter diagonal: ";
        cin>>dev.diagonal;
        cout<<"Enter quality: ";
        cin>>dev.quality;
         return is;
}
std::ostream& operator << (std::ostream &os, printDevice &dev)
{
    return os<< "Interface: "<< dev.interface <<std::endl
             << "Power: "    << dev.power     <<std::endl
             << "Weight: "   << dev.weight    <<std::endl
             << "Diagonal: " << dev.diagonal  <<std::endl
             << "Quality: "  << dev.quality   <<std::endl;
}

#pragma once
ref class main
{
public:
    main(void);
};

#include "main.h"
#include "Device.h"
#include "printDevice.h"
#include "Advertising.h"
using namespace std;
main::main(void)
{
}
int main()
{
    printDevice a;
    cin>>a;
    cout<<a;
    system("pause");
    return 0;
}

#include <iostream>
#include <cstring>
 #include <fstream>
#include<istream>
#include<iostream>
#include<string>
#pragma once
using namespace std;
class Device
{
protected:
    std::string interface;
    int power;
    int weight;
public:
 virtual void setPower(); 
    void output_interface() { std::cout<<interface<<std::endl; }
    void output_power()     { std::cout<<power<<std::endl;     }
    void output_weight()    { std::cout<<weight<<std::endl;    }
 
    void input_interface();
    void input_power();
    void input_weight();
 
   void  operator()(const char *, int, int);
    Device & operator=(Device &dev);
    friend std::istream & operator>>(std::istream &is, Device &dev);
    friend std::ostream & operator<<(std::ostream &os, Device &dev);
    Device(std::string str = "0", int x = 0, int y = 0): interface(str), power(x), weight(y) {}
    ~Device() {}
};

#include "Device.h"
#include <fstream>
#include<istream>
#include<iostream>
#include<string>
#include <cstdlib>
#include <vector>
using namespace std;
 
void Device::input_interface()
{
    std::cout<<"Enter the device interface: ";
    getline(std::cin, interface);
}
 
void Device::input_power()
{
    std::cout<<"Enter the device power: ";
    std::cin>>power;
}
 
void Device::input_weight()
{
    std::cout<<"Enter the device weigth: ";
    std::cin>>weight;
}
   void Device::setPower() {
        cout << "Enter power: " << endl;
        cin >> power;
    }
void Device::operator()(const char *str, int x, int y)
{
    interface = str;
    power     = x;
    weight    = y;
    
}
 
Device & Device::operator=(Device &dev)
{
    if (this != &dev) {
        interface = dev.interface;
        power     = dev.power;
        weight    = dev.weight;
    }
    return dev;
}
 
std::istream & operator>>(std::istream &is, Device &dev)
{
    return is>>dev.interface>>dev.power>>dev.weight;
}
 
std::ostream & operator<<(std::ostream &os, Device &dev)
{
    return os<<"Interface: "<<dev.interface<<std::endl
                 <<"Power: "    <<dev.power<<std::endl
                 <<"Weight: "   <<dev.weight<<std::endl;
}

#pragma once
class main
{
public:
    main(void);
};

#include "main.h"
#include "Device.h"
#include "printDevice.h"
// #include "Advertising.h"
using namespace std;
main::main(void)
{
}
int main()
{
    printDevice a;
    cin>>a;
    cout<<a;
    system("pause");
    return 0;
}

class printDevice:public Device{