C++ scope operator grouping? - c++

Question

Is there a way to group methods scoped to a specific class, without using the scoping operator :: every time? At risk of arousing contempt in some, I can make a rough analogy to the JavaScript with statement; however, here it is used in the source, and not executed.
A simplified example: imagine a Cheese class, with the weigh, shred, and melt functions declared as follows:
class Cheese {
public:
Cheese();
... // other constructors, copy, etc.
~Cheese();
int weigh();
int shred();
int melt();
}
Typically the functions definitions are as follows:
Cheese::Cheese() { //constructor stuff };
... // other constructors, copy, etc.
Cheese::~Cheese() { //destructor stuff };
int Cheese::weigh() { return weighed; }
int Cheese::shred() { return shredded; }
int Cheese::melt() { return melted; }
Is there a way to say, "Hey compiler, all these definitions are scoped to the Cheese class."
Perhaps like so?
scope::Cheese {
Cheese() { //constructor stuff };
... // other constructors, copy, etc.
~Cheese() { //destructor stuff };
int weigh() { return weighed; }
int shred() { return shredded; }
int melt() { return melted; }
}
or,
Cheese:: {
Cheese() { //constructor stuff };
... // other constructors, copy, etc.
~Cheese() { //destructor stuff };
int weigh() { return weighed; }
int shred() { return shredded; }
int melt() { return melted; }
}

Answer 1

Other than defining the methods in the function definition block itself (which has various potential disadvantages), no, there is not any way to do this.
At least part of the reason for this is to ensure that classes, unlike namespaces, cannot be "re-opened" to have additional members added.

Answer 2

You can
define the methods fully in the class definition, or
except for constructors and destructors, use a typedef short class name for the implementation.
There are also some less practical possibilities, which include source code preprocessing.
Example:
class Cheese
{
public:
Cheese();
//... // other constructors, copy, etc.
~Cheese();
auto weight() -> int;
auto shred() -> int;
auto melt() -> int;
};
using X = Cheese;
Cheese::Cheese() {}
Cheese::~Cheese() {}
auto X::weight() -> int { return 0; }
auto X::shred() -> int { return 0; }
auto X::melt() -> int { return 0; }
auto main() -> int
{
return Cheese().weight();
}
On a personal note I wish more libraries were header only, with the method definitions in the class definitions. The header only approach can't easily deal with module cross-dependencies, where the implementation of X depends on interface of Y and vice versa, and with current 1960's build technology it can cause impractically long build times. But where the latter problem matters it can be and is often addressed by pouring more hardware on the problem, and happily the first problem is a rare one.