Is passing an extra unused parameter/message to a callback good practice?

edit

I'm writing a node that advertises several (15+) services, and to simplify the interface and unclutter the code, I am using a generic service callback using a ros::ServiceEvent to specialize the execution within the callback, although differentiating between services that require passing a float parameter or just simple triggers :

bool triggerServiceCallback(onst ros::ServiceEvent<std_srvs::Trigger::Request, std_srvs::Trigger::Response>& event) {
    const ros::M_string& header = event.getConnectionHeader();
    std::string service_name = header.at("service");

    auto response_ptr = header.getResponse();

    switch(service_name) {
        case "service_a":
            response_ptr->message = "A";
            response_ptr->success=true;
        case "service_b":
            response_ptr->message = "B";
            response_ptr->success=true;
        /* ... */
        default:
            return false;
    }
    return true;
}

bool paramServiceCallback(onst ros::ServiceEvent<std_msgs::Float32, std_srvs::Trigger::Response>& event) {
    const ros::M_string& header = event.getConnectionHeader();
    std::string service_name = header.at("service");

    auto response_ptr = header.getResponse();

    switch(service_name) {
        case "service_c":
            response_ptr->message = "C: " + std::to_string(header.getRequest()->data);
            response_ptr->success=true;
        case "service_c":
            response_ptr->message = "D: " + std::to_string(header.getRequest()->data);;
            response_ptr->success=true;
        /* ... */
        default:
            return false;
    }
    return true;
}

My question is related to both code correctness and runtime efficiency. I could further simplify this approach and use one single callback for all services, ignoring the request entirely in the first set of services where no data needs to be passed to the server node. That would greatly simplify the code (e.g. allowing me instantiate ros::ServiceServer on a loop without having to match each ros::ServiceServer to each type of callback), but that would entail transporting/passing an object without needing it - would that entail a significant overhead (it's just a float after all) - what is the customary approach/rule of thumb regarding this kind of implementation?