Disable code based on existence of Constructor

Question

I am trying to disable some code based on whether the code creates an Object or not (or calls a function or whatever). Sounds a bit strange, I know.

In my library it is possible to create 2 objects, each object needs an interrupt service routine like:

ISR(TIMER0_COMPA_vect) {
  // do some stuff if the interrupt happens
}

The ISR can only be created once but it could be possible that the user just creates one or none of my objects, so the ISR shouldn't be created in the first place to not block the creation of one by the user. I know it would be easy to encapsulate the code like this

#ifdef OBJECT1
  ISR(TIMER0_COMPA_vect) {
    // do some stuff if the interrupt happens
  }
#endif

but that forces the user to keep track of the objects she/he created. Is there an option to let the preprocessor decide if, let's say, the constructor is called once or even existent? A little bit like something like this

Foo:Foo() {
  #define USE_FOO
  //Some code
}

#ifdef USE_FOO
ISR(TIMER0_COMPA_vect) {
  // do some stuff if the interrupt happens
}
#endif

EDIT:

Based on the answers i got, I try to clarify my question a bit:

Foo1:Foo1() {
    //Some object constructor code
}

Foo2:Foo2() {
    //Some object constructor code
}

ISR(TIMER1_COMPA_vect) {
    //some interrupt code
}

ISR(TIMER2_COMPA_vect) {
    //some interrupt code
}

int main() {
    Foo2 foo2;
}

If this is the code we are talking about, the function ISR(TIMER1_COMPA_vect) shouldn't be compiled at all. The ISR MUST be absent.

PS: if you need more information, I can provide more but I tried to keep the problem as basic as possible

Answer 1

Typically what you would do for this type of situation is compile the code for such an object into a library. The linker is smart enough to detect if your main program depends on any function from the library. If it does, it will load the entire compilation unit (i.e. the .c or .cpp file) of that function into your program. Any ISRs that it finds in the compilation unit will be added to your program. If you don't use any functions from the library, the ISRs will not be added.

For example, put something like this in foo1.h:

#pragma once
class Foo1 {
public:
  Foo1();
};

Put something like this in foo1.cpp:

#include <foo1.h>

ISR(TIMER1_COMPA_vect) {
}

Foo1::Foo1() {
}

Now you should compile foo1.cpp into foo1.o using avr-gcc. Next, use avr-ar to store foo1.o in an archive named foo1.a. Then, compile your main program with avr-gcc, and provide foo1.a as an argument. Make sure the foo1.a argument comes after main.cpp.