Disable all class member functions if the class is empty - c++

Question

I have a diagnostic drawing class to graphically plot the status of objects in a multithreaded environment. But this is costing me CPU cycles when I don't run in the diagnostic mode. I don't want to check every line for diagnose mode too. Rather I like to a declare the diagnostic object as empty ( or through some other member functions/ extra variables) and all the diagnostic member functions will be rendered irrelevant. Is this possible? I dont't want to change the existing member functions
bool dmode = true; // want to avoid this
class plot{
void draw();
};
class foo{
void something(){
plot p;
if(dmode) p.draw(); // don't want the checking as plot objects are littered everywhere.
}
};
Edited:
// dmode will be decided only at run time based on my settings configuration

Answer 1

Compile time discard
You may use constexpr:
constexpr bool dmode = true;
//...
if constexpr (dmode) {
Using constexpr this way will make sure the branch is discarded at compile time
It should be noted that this is a c++17 feature, before that you can use macros to discard code at compile time.
A third option is to just rely on compiler optimizations(ie. constant folding), but it is much harder to give any guarentees and might not be feasible for a debug build if that is ever the case.
Runtime solution
Assuming your draw function is virtual - you then need to somehow make a non-virtual function to stick the if into. Then one way to accomplish this is by making the virtual function private.
class plot{
public:
void draw() {
if (!dmode) {
return;
}
do_draw();
}
private://<-- or protected
virtual void do_draw() = 0;//rename in all subclasses
};
However, this is just one way to solve it - without knowing more of the actual case its hard to say which method is more appropriate.

Answer 2

You can do the check inside the draw() function:
void plot::draw() {
if (!dmode) {
return;
}
// Do the actual drawing.
}
If that's not an option for some reason, you could make plot a pure abstract class, and provide two implementations, RealPlot and NullPlot. Then create a function create_plot() that, depending on the value of dmode, returns either a RealPlot or a NullPlot instance.

Answer 3

You have options. Here are some of them:
Concepts - C++20
constexpr bool dmode = true;
class plot
{
public:
void draw() requires (!dmode)
{
/* actual implementation */
}
void draw() requires dmode
{
// empty
}
};
class foo
{
void something()
{
plot p;
p.draw();
}
};
Constexpr if - C++17
constexpr bool dmode = true;
class plot
{
public:
void draw()
{
if constexpr (!dmode)
{
/* actual implementation */
}
}
};
class foo
{
void something()
{
plot p;
p.draw();
}
};
Templated class and an alias - C++11
constexpr bool dmode = true;
template <bool Dmode>
class plot_base
{
public:
void draw()
{
/* actual implementation */
}
};
template <>
class plot_base<true>
{
public:
void draw()
{
// empty
}
};
template <bool Dmode = dmode>
using plot = plot_base<Dmode>;
class foo
{
void something()
{
plot<> p;
p.draw();
}
};
Mock (a.k.a. None of the above)
And ultimately (most likely) none of the solutions are appropriate. It seems to me like what you want is a mock. So look into that.