Two files using each other funtions - how to solve it? - c++

Question

I have two headers with source files, lets say file1.h, file1.cc and file2.h, file2.cc. They use each others functions, for example:
file1.h:
void test1();
file2.h:
void test2();
file1.cc:
#include "file1.h"
#include "file2.h"
void test1() {
do_something();
test2();
}
file2.cc:
#include "file1.h"
#include "file2.h"
void test2() {
do_something_else();
test1();
}
I get the problem, the dependancy is mutual and we cant compile one file without having another compiled. How to solve this problem?

Answer 1

Modify the files to remove the double recursion.
Use some code to prevent double inclusion of your .h files (I have used #pragma once at the top of the .h files)
optionally, add a main.cpp to call the functions
provide code for do_something()
compile using . g++ *.cpp -o main
Great question!
Here are the files:
// main.cpp
//
#include <iostream>
#include "file1.h"
#include "file2.h"
int main() {
test2();
std::cout << "Hello, World!" << std::endl;
return 0;
}
// file1.cpp
#include "file1.h"
#include "file2.h"
#include <iostream>
void do_something() {
std::cout << "Just hit do_something" << std::endl;
}
void test1() {
do_something();
// test2(); // Do not use double recursion.
}
// file1.h
#pragma once
void do_something();
void test1();
// file2.cpp
#include "file1.h"
#include "file2.h"
void test2() {
do_something();
test1();
}
// file2.h
#pragma once
void test2();

Answer 2

The best answer is don't design your code like that! This introduces a "circular dependency," which immediately makes your code fragile. Additionally, the way you have your example written describes a double-recursive function (A calls B which calls A), and since there is no terminating condition, is unbounded! As you can see, this can lead to some very unmanageable circumstances.
Let's forego good engineering practices for a while. How you described both headers & source files is adequate and can be built with the following command:
g++ file1.cc file2.cc -o libCoupledRecursiveExample.so
This is where things become difficult: through the build instructions alone, you can't actually detect the dependency! Good static code checkers can detect these circumstances and warn you, but when you use a lazy compiler (like g++ without flags), it's easy to sneak by code like this that won't generate any warnings.