How to do C++ custom structured array subscript operator overload?

Question

I want to provide an subscript operator structure for the struct I am writing. I plan to do this with two structs foo and bar. Code is as follows:

#include <iostream>
struct foo;

struct bar{
    uint32_t *mem;
    uint32_t *opcode;

    bar():mem(nullptr),opcode(nullptr){}
    bar( foo *f, int index ){
        this->mem = f->memory + (index%16);
        this->opcode = f->instructions +(index%16);
    }
    operator bool(){ return (this->mem != nullptr) & (this->opcode != nullptr); }
};
std::ostream& operator<<( std::ostream& os, bar &t ){
    if( t ){
        return os << "bar:" << (*t.mem) << "\t-\t" << (*t.opcode);
    }else{
        return os << "bar: NOT INITIALIZED";
    }
}

struct foo{

    uint32_t *memory = new uint32_t[16]();
    uint32_t *instructions = new uint32_t[16]();

    foo(){}

    ~foo(){
        delete[] this->memory;
        delete[] this->instructions;
    }

   bar &operator[]( int index){
      return bar( *this, index%16 );
   } 

};
std::ostream& operator<<( std::ostream& os, foo &f ){
    for( int i =0 ; i < 16; i++ ){
        os << f.memory[i] << "\t" << f.instructions[i] << "\n";
    }
    return os;
}

I am using CygWin[x86_64] and Notepad++ as main compiler and editor on Windows 7 64 bit.

I have tried a lot of permutations on my own to fix this problem, but I would like to show the following:

bar( foo *f, int index ){
    this->mem = f->memory + (index%16);
    this->opcode = f->instructions +(index%16);
}

and 

bar( foo *f, int index ){
    this->mem = f->memory[index%16];
    this->opcode = f->memory[index%16];
}

'f' is incomplete type error, with note that I have used forward declaration.

bar( foo *f, int index ){
    this->mem = f->memory[index%16];
    this->opcode = f->memory[index%16];
}

two forward declarations notes, and two invalid use of incomplete type struct foo on this->mem = f->memory[index%16] and this->opcode = f->memory[index%16];

---

I have tried a bunch of other stuff but it seems I have mostly an issue with incomplete type. I have searched SO for answers, and one did explain what is incomplete type, other issue was about recursive definition and this one doesn't define how to make an incomplete type complete.

I am hung on this for past several days, going trough iterations for simple operator overloading. Maybe I am phrasing it wrong in questions, or searching for wrong answers.

But can someone point out my mistakes and/or write how to overload array subscript operator with code and not just body less functions?

Answer 1

Basic design problems (which don't relate to your question) aside, there are two three things that keep this from compiling:

1. The body of the constructor bar::bar(foo*,int) is defined inline, and uses members from foo. Since foo isn't defined yet (it's an incomplete type), the compiler chokes because it doesn't know about the members of foo yet.

2. When you call the constructor, you pass in a foo &, not a foo *.

3. foo::operator[] returns a non-const reference to a temporary, which some compilers might accept, but is just plain wrong. (spotted by Ted Lyngmo)

The following code compiles (https://godbolt.org/z/_F_ZpJ):

#include <iostream>
struct foo;

struct bar
{
    uint32_t *mem;
    uint32_t *opcode;

    bar():mem(nullptr),opcode(nullptr){}
    bar( foo *f, int index );
    bar (bar const &) = default;  // add default copy constructor
    operator bool(){ return (this->mem != nullptr) & (this->opcode != nullptr); }
};


struct foo{

    uint32_t *memory = new uint32_t[16]();
    uint32_t *instructions = new uint32_t[16]();

    foo(){}

    ~foo(){
        delete[] this->memory;
        delete[] this->instructions;
    }

   bar operator[]( int index){
      return bar( this, index%16 ); // this, not *this
   } 

};


bar::bar( foo *f, int index )   // moved the definition down here
{
     this->mem = f->memory + (index%16);
     this->opcode = f->instructions +(index%16);
}

std::ostream& operator<<( std::ostream& os, bar &t )
{
    if( t ){
        return os << "bar:" << (*t.mem) << "\t-\t" << (*t.opcode);
    }else{
        return os << "bar: NOT INITIALIZED";
    }
}


std::ostream& operator<<( std::ostream& os, foo &f )
{
    for( int i =0 ; i < 16; i++ ){
        os << f.memory[i] << "\t" << f.instructions[i] << "\n";
    }
    return os;
}

As I already said, there are some basic design problems and you should think about redesigning this code. Something like the code at this link is better. Better yet, ditch foo altogether use the refactoring suggested in TJ Bandrowsky's answer.

Answer 2

I'd consider refactoring the thing to something like:

bar {
uint opcode, mem;
}

then make your machine model a std:vector and it would be a lot simpler.