I think you are conflating several concepts here, and there can be some overlap. Since you did not tag this with a language, I will defer to the general definitions of the words as they mean to me as a software professional of over 15 years:
No-argument constructor is a constructor that accepts exactly zero arguments.
Default constructor is a constructor that can be invoked without any explicit arguments. This may be a no-arg constructor, or it may have default parameters.
Compiler-generated constructor is one that the compiler creates for you in the absence of an explicitly-defined constructor. This will typically be a no-arg constructor. Note: C++ may also generate other constructors, although the rules are not so simple anymore as of C++11.
To me, the word "default" means what happens if I do nothing.
I agree, in the sense of "do nothing" meaning "I do not provide any arguments, regardless of whether the compiler provides them for me as default parameters."
So I feel that the "default constructor" should refer only to the one that the compiler provides if I do not write any.
Why can the programmer not provide a default constructor? Often they would be equivalent in terms of interface, at least: the only reason for providing a default constructor is to initialize state that would not be done in a do-nothing implementation, or to call another constructor (i.e.
I don't see that this is an agreed-on convention though, because many people use "default constructor" to mean the same thing as "one with no arguments"
I see this sometimes as well, but I think the semantic difference is "can be constructed without providing any arguments" which is consistent with the definition I provided.
But that is not the case for other types of methods.
There is a subtle distinction here. In every language I am familiar with, all constructors are not functions. While the term "overload" may apply to both, overloaded functions are technically separate entities with different method signatures but the same name. Constructors are special in that while they may also be overloaded, they represent the same thing and share the same responsibility (object initialization).
Furthermore, constructors are generally not part of a class's interface: it is not possible to call a constructor except when creating the object. Constructors and methods/functions are different animals and must be treated differently when discussing a class's interface. There is simply no comparison between the two entities except that constructor invocations look similar to method invocations (the difference being one does not invoke a constructor using an object reference).