如何将在一个类中声明的类的数据类型访问到另一个类中（两者都在不同的翻译单元中）？

Question

I have 5 files. (1. A.hpp, A.cpp : 2. B.hpp, B.cpp : 3 main.cpp)

// A.hpp
#ifndef MY_CLASS_A
#define MY_CLASS_A

#include <iostream>

class B; // forward declaration so that I could do B * b;

struct s {
    int x;
    double y;
};

class A{
    s my_struct;
    int size;
    B * b;
public:
    A(int, double, int);
    void f1(s);
    void f2(); // this function calls B's f1 function
    s get_struct();
    int get_size();
    void print();
};

#endif

Then I have its implementation as

// A.cpp
#include "A.hpp"
#include "B.hpp"

A::A(int x_, double y_, int size_):my_struct({x_, y_}), size(size_){}  

void A::f1(s s_){
    // do stuff   
    s_.x = 5;
    s_.y = 51.99;
}

void A::f2(){

    int val;   
    // Here I am calling B's f1 function
    val = b->f1(my_struct);

}

s A::get_struct(){

    return my_struct;
}

int A::get_size(){

    return size;
} 

void A::print(){
    std::cout << " ----- " << std::endl;
    std::cout << "x    = " << my_struct.x << std::endl;
    std::cout << "y    = " << my_struct.y << std::endl;
    std::cout << "size = " << size << std::endl; 
    std::cout << " ----- " << std::endl;
}

Then I have B

//B.hpp
#ifndef MY_CLASS_B
#define MY_CASS_B

#include "A.hpp" // I placed here A.hpp because I am 
                 // trying to use A's struct type 

class A;

class B{

public:
    int f1(s); // A's struct use here to get struct by value

};

#endif

and its implementation as

// B.cpp
#include "B.hpp"

 //  used A's struct here again
int B::f1(s my_struct){ 

    std::cout << "*****" << std::endl;
    std::cout << my_struct.x << std::endl;
    std::cout << my_struct.y << std::endl;
    std::cout << "*****" << std::endl;
}

finally main as

// main.cpp
// As per comment I should place #include "A.hpp" here 
#include "A.cpp"

int main(){

    A a(4,9.9, 5);
    a.print();
    return 0;
}

My main question is how can I access the struct declared in class A into class B? I have tried to use forward declaration by failed miserably.

Answer 1

Open your C++ book to the chapter on pointers and references, and read that chapter again.

"The struct declared in class A" is my_struct , which is a private class member.

To have it accessible elsewhere, you need to pass it by reference.

int B::f1(const s &my_struct){ 

    std::cout << "*****" << std::endl;
    std::cout << my_struct.x << std::endl;
    std::cout << my_struct.y << std::endl;
    std::cout << "*****" << std::endl;
}

Now, when you invoke this from A :

val = b->f1(my_struct);

This will now pass a reference to the my_struct member, instead of making a copy of it.

Note that the parameter is declared as a reference to a const instance of s , because f1() does not need to modify it. If it does, simply pass it as a non-const reference:

int B::f1(s &my_struct){ 

Now, f1() will be able to modify my_struct , and end up modifying this private instance of A 's class, that was passed to it.

PS This has nothing to do with different translation units. Whether this whole thing is in one translation unit, or is split across half a dozen of them, classes and references work the same way.