Question

class RLE_v1
{
    struct header
    {
        char sig[4];
        int fileSize;
        unsigned char fileNameLength;
        std::string fileName;
    } m_Header;

    RLE<char> m_Data;

public:
    void CreateArchive(const std::string& source)
    {
        std::ifstream::pos_type size;
        char* memblock;
        std::ifstream file (source, std::ios::in|std::ios::binary|std::ios::ate);
        if (file.is_open())
        {
            size = file.tellg();
            memblock = new char [static_cast<unsigned int>(size)];
            file.seekg (0, std::ios::beg);
            file.read (memblock, size);
            file.close();
            //
            // trying to make assignment to m_Data here.
            //
            delete[] memblock;
        }
    }

    void ExtractArchive(const std::string& source);
};

I’m trying to copy the data in the “memblock” char array into the variable m_Data, but when I try to do it I get the error that no match for operator "=" matches these operands. I have no idea how to make them equal, because m_Data is already of type char.

This is the RLE class that has the variable m_Data as a mem

template <typename T>
struct RLE
{

    T* m_Data;  // Memory which stores either compressed or decompressed data
    int m_Size; // Number of elements of type T that data is pointing to

    RLE()
        : m_Data(nullptr)
        , m_Size(0)
    { }

    ~RLE()
    {
        delete m_Data;
    }
};

Answer 1

You’ve shown everything except the actual line that produces the error.

But what I see is this. You have a class that has the member:

RLE<char> m_Data;

After template expansion, that struct will have the member:

char *m_Data;

You say there is no operator= when you assign memblock to m_Data. So I can only conclude that you are doing this:

m_Data = memblock;

Where you should actually be doing this:

m_Data.m_Data = memblock;
m_Data.m_Size = size;

Instead of directly operating on a struct’s internals, you might be better off making a function:

template <typename T>
void RLE<T>::Alloc( size_t size )
{
    if( m_Data != nullptr ) delete [] m_Data;
    m_Data = new T [size];
    m_Size = size;
}