Passing SDL_Event by Reference (&E) in SDL2 Event Handling

When passing arguments to functions in C++, we primarily choose between pass-by-value, pass-by-reference, and pass-by-pointer. In the lesson's HandleEvent function, we pass the SDL_Event by reference (&E).

Pass-by-Value vs. Pass-by-Reference

Pass-by-Value: When you pass an argument by value, the function receives a copy of the original variable. Any modifications made to the parameter inside the function affect only the copy, not the original variable outside the function.

1void Function(int valueParam) {
2  valueParam = 10; // Modifies the copy only
3}
4int main() {
5  int original = 5;
6  Function(original);
7  // original is still 5 here
8  return 0;
9}

Pass-by-Reference: When you pass an argument by reference (using & in the function parameter declaration), the function receives a reference (an alias) to the original variable. Modifications made to the parameter inside the function directly affect the original variable.

1void Function(int& refParam) {
2  refParam = 10; // Modifies the original variable
3}
4int main() {
5  int original = 5;
6  Function(original);
7  // original is now 10 here
8  return 0;
9}

Why Use Reference for SDL_Event?

The main reason for passing SDL_Event E by reference (SDL_Event& E) is efficiency.

The SDL_Event type is a union. This means it's designed to hold different kinds of event data (keyboard, mouse, window, joystick, etc.) within the same memory location. Some of these nested event structures can be relatively large.

1typedef union SDL_Event {
2  Uint32 type; // Event type
3  SDL_WindowEvent window; // Window event data (large)
4  SDL_KeyboardEvent key; // Keyboard event data (large)
5  SDL_MouseMotionEvent motion; // Mouse motion data
6  SDL_MouseButtonEvent button; // Mouse button data
7  // ... other event types
8} SDL_Event;

If we passed SDL_Event by value, the entire structure (potentially large, depending on the event type currently stored) would be copied every time HandleEvent is called for every object interested in events. In a loop like while (SDL_PollEvent(&E)), this copying could happen many times per frame, potentially impacting performance, especially if many objects handle events.

Passing by reference avoids this copy. The HandleEvent function works directly with the original E variable fetched by SDL_PollEvent.

Pass-by-const Reference

In our specific HandleEvent example, the function only reads the event data; it doesn't modify the event E itself. In such cases, it's even better practice to pass by constant reference (const SDL_Event& E):

1// Rectangle.h
2class Rectangle {
3public:
4  // ...
5  // Pass by const reference
6  void HandleEvent(const SDL_Event& E) { 
7    // Now we can only read from E, not write to it
8    if (E.type == SDL_MOUSEMOTION) {
9       // ... okay to read E.motion.x
10    }
11    // E.type = SDL_QUIT; // This would cause a compile error 
12  }
13  // ...
14};

Using const& has two benefits:

1. Efficiency: It still avoids the copy, just like &.
2. Safety/Clarity: It clearly signals to anyone reading the code that the function will not modify the passed-in event, and the compiler enforces this promise.

While passing by non-const reference (&) works and avoids the copy, passing by const& is often preferred when the function only needs read access to the argument.