[C++] how do you avoid copying declarations into methods' definitions?

Jow Forums, how do you avoid copying declarations into methods' definitions?

1. nested definition (this may cause many problems)
class MyClass {
public:
void myMethod(const int someValue) {
doSomething(someValue);
}
};

2. declaration duplication
class MyClass {
public:
void myMethod(const int someValue);
};

MyClass::myMethod(const int someValue) { // such an annoying duplication!
doSomething(someValue);
}

3. ???

inb4 usage of external preprocessors

Attached: if_source_cpp_3761.png (128x128, 5K)

Other urls found in this thread:

en.cppreference.com/w/cpp/language/inline
twitter.com/NSFWRedditGif

You rewrite it in Rust

You don't avoid copying them. That's part of C++, just deal with it. Maybe modules will change that one day.
Or

MyClass.h:
#ifndef MYCLASS_H
#define MYCLASS_H

class MyClass {
public:
void myMethod(const int someValue);
};

#endif

MyClass.cpp:
#include "MyClass.h"

MyClass::myMethod(const int someValue)
{
doSomething(someValue);
}

I don't care if you find it annoying. This is the correct, standard practice method of doing things.

inline void myMethod(...) wherever you can, when you cannot break dependencies you must duplicate the declaration. inline tells the compiler to ignore duplicate identical definitions, which would appear if you included the same header twice

In general I write everything inline as long as I can, then when the errors start piling up I spend an hour moving everything to external definitions

I think of all the problems with C++, this is the worst (const bullshit is up there too)

if you can afford using a supercomputer to run the executable...

Rust compilation uses LLVM so it's pretty much the same as C or C++ using Clang as to this.
What is your issue with Clang?

1. Nothing bad should ever happen if you include headers twice. See include guards or pragma once
2. inline tells the compiler to avoid making the function *call* (allocating stack, returning, etc), and instead just insert the code in the very place you use your inline function. Although this is only a hint to a compiler.

rust is a bloated layer over c/c++.
I don't care what cc it uses later to compile this bloat.

no code duplication is correct
you need to change it twice, you can totally fuck up your program if you forget to change it in one place (and it may still compile!)