Group Actions
Engagement
  • Author Author: Jan Cumps
  • Date Created: Date Created
  • Views 554 views
  • Likes 5 likes
  • Comments 3 comments
Related
Recommended

C++ classes and operators

Jan Cumps

This is a "classic C++" post, something that's been part of the language since conception: How to use an operator in your class design.

I developed a callback class. Your "gizmo that needs to callback something" would hold an instance of that class (an object). And you 'd assign some function to that object.

Callback<int> cb;
cb.set([]() -> void {
    start_video();
});

When the time is ripe (usually an event: an interrupt, a mouse click, UART data arrived, ...) you ask the callback class to execute that function. In this blog, I'm pretending that I'm a button, and someone clicked me. The effect should be that the start_video() callback gets executed.

In my original design, you reacted on that by calling the callback class call() method:

bool button1::clicked() {
    cb.call();
}

This would execute the start_video(). 

However, in C++ there is a standard way to indicate that something is a call and that you "execute the object" : the operator (). Similar to the operator +, that indicates that you want to add. I want that my class follows that paradigm.

This is how I want that a call should look like:

button1::clicked() {
    cb();
}

It again should call start_video(). Like the originall call() method did.

Implementing this isn't hard. In my Callback template class, I just had to replace call() by operator ():

class Callback {
public:
	// ...

	inline void operator()() {
	    // call the registered callback
	}
	
	// ...

};

in reality, my class is template driven, and will accept callbacks with any type / count of parameters. I've removed that for blogging simplicity.

Opinions on this topic may vary. I think that operator() indicates perfectly that you want the callback class to execute the callback handler. Let me know if you have a different preference.

Parents

  • Here is how I used this in Raspberry Pico code, where I use a callback when i need data from UART:

    callbackmanager::Callback<void, std::string&> reader;

reader.set([](std::string& s) -> void { read(s); });
// read is a Pico function that gets all available data from the controller's UART buffer.
// it stores the results in the std::string tht's passed to it as a reference.

    In my business logic, that doesn't know anything about Pico or UART, I invoke a read by calling that callback:

    // In my business logic

void mybusinessclass::read(std::string& s) {
    reader(s);
}

    The callback class will call that read() function we set earlier, to get the data from the UART, and put it in std::string s.

Comment

  • Here is how I used this in Raspberry Pico code, where I use a callback when i need data from UART:

    callbackmanager::Callback<void, std::string&> reader;

reader.set([](std::string& s) -> void { read(s); });
// read is a Pico function that gets all available data from the controller's UART buffer.
// it stores the results in the std::string tht's passed to it as a reference.

    In my business logic, that doesn't know anything about Pico or UART, I invoke a read by calling that callback:

    // In my business logic

void mybusinessclass::read(std::string& s) {
    reader(s);
}

    The callback class will call that read() function we set earlier, to get the data from the UART, and put it in std::string s.

Children
  • in reply to Jan Cumps

    I've used explicit types in the code above,

    reader.set([](std::string& s) -> void { read(s); });

    but you can also use auto:

    reader.set([](auto& s) { read(s); });

    Both constructs are identical, and enforce the same strong type checks. auto is a useful way to (amongst other things) type less.

  • in reply to Jan Cumps

    If you are into design patterns: this is dependency injection.

    Instead of learning my business logic how to read UART on a Raspberry Pico, I insert a function that knows how to do that.

    The only contract is that both have to agree upon, is the signature of that function, and what each parameter does (in this case: that the UART data "will be" / "has to be" placed in the string parameter.

    If I want to use this on an other platform (Arduino, Pi, ...) the business logic doesn't need changes. I just have to take care that I write an Arduino / Pi function that can read from UART and place that info in the s parameter. And set that function in the callback manager.