Suppose I have a function that takes two arguments,
void f(int x, int y);
and I want to bind one of them. I can use std::bind as follows:
auto partiallyBoundF = std::bind(f, 10, _1);
partiallyBoundF takes only one argument, but I can call it with more than one. The arguments beyond the first don't even have to be of a type that makes any sense:
partiallyBoundF(20, 0);
partiallyBoundF(0, 44, -99, "Hello", 4.5, true, []{});
What is the purpose of permitting objects returned from bind to be passed extra arguments? It allows calling errors to compile that would be rejected anyplace else.
Ignoring extra arguments is a lot simpler to implement, and can actually be useful.
In a typical implementation e.g. libstdc++ (g++), the approach taken is to collect the operator() arguments into a tuple and then let the std::placeholder bind arguments extract them as required. Enforcing argument count would require counting the number of used placeholders, which would be pretty complicated. Note that the bind callable can be a functor with multiple or templated operator() call patterns, so the bind object operator() can't be generated with a single "correct" signature.
Also note that you can write:
std::bind(&foo, std::placeholders::_1, std::placeholders::_3);
i.e. explicitly ignoring the second argument to the bind object. If bind enforced its argument count you would need an additional way to specify that e.g. a fourth argument was also to be ignored.
As for usefulness, consider binding a member signal handler to a signal:
sig.connect(std::bind(&C::on_sig, this, param, std::placeholders::_1));
If sig has extra unwanted emission parameters, then they are simply ignored by the bind object; otherwise, binding the same handler to multiple signals would require writing multiple forwarding wrappers for no real purpose.