Can you post your header file? The way you're doing it sounds correct to me.

Quote:"I declare the member function (in the header file) right after the class definition."

Do you mean DEFINE? Member functions must be declared in the class, but you may DEFINE them after the class definition.

Any function in a header should be either static or inline.

Member functions defined within class declarations are already inline.
For others, you need to specify inline yourself.

Quote:
Whenever a class, a member function or both are templated, it must be defined in the header file.

Actually, they only need to be defined somewhere where they will be visible to anything that will consume it. In practice, however, this does mean that the overwhelming majority of template functions must be implemented in headers, otherwise they're available only to the translation unit of the .cpp file they're contained in (sometimes this is desirable). The compiler will not stop you from defining templates in a source file.

Quote:
Also, a member function to be inline must be declared inside the class definition

Close -- a member function defined inside the class definition is implicitly marked inline.

Quote:
Now, I have a templated class with (sometimes templated) member functions, most of which I'd rather keep as a normal function, not an inline function. To keep the class definition clean, I declare the member function (in the header file) right after the class definition.

Your terminology is inaccurate. I have an idea of what you are probably doing wrong, but you should provide an example of your code to be sure.

To declare a function is:

ReturnType FunctionnName(/* possible parameters */);

To define one is:

ReturnType FunctionnName(/* possible parameters */) {  // Code and stuff...}

That said...

Quote:
Why does inline-ness of a function determines the number of times it's declared? Must the functions be inline to fix this problem?

It doesn't, and the number of times the function is declared isn't a problem. It's the number of times it's defined, which is what I suspect you're actually doing when you say you declare the functions outside the class definition.

If those functions are not marked inline, and are not templates (either directly or via their containing class), then they will be defined every time the compiler sees them, and since every source file is compiled in isolation, every source file that sees that header will define those functions, which means when the linker gets around to patching things up, it sees N different definitions for the same thing and throws up its hands in frustration.

Templates and inline function definitions are the 'exception' to the one-definition-rule because they have to be available to the compiler where they are used. A compiler could not ever inline a function if it doesn't know what the function looks like.