What is a member function in c++?, does it contain a body?, is it defined in the .h or .cpp file? [closed]

Question 1

Alternate syntax:

class MyClass{
    public:
    void MyFunction(void);   // prototype
}

MyClass::MyFunction(void){   // actual function
    // code goes here
}

Question 2

I am confused by the term of member function

Everything that belongs to a class or a struct is called a member of that class. Hence, we can have member functions. Below is a little exmaple:

class MyClass
{
public: 
  MyClass();
  void myFunction();
  int number;
}

Here you have myFucntion() and number members of MyClass

Do we have to define it in the header .h file or the .cpp file?

In C++, it doesn't matter where you define or declare a function or a class.

But keep in mind that putting declaring classes in .h files is better. It will lead to faster compilations of your project. So you should have something like:

// myClass.h

class MyClass
{
public: 
  MyClass();
  void myFunction();
  int number;
}

// myClass.cpp

myClass::myClass()
{
  // this is a constructor
  number = 10;
}

void myClass::myFunction()
{
  // this is my function
  cout << number;
}

Question 3

Every function in C++ is a member

Member of a namespace. These are sometimes called "global functions", although that termis not completely correct. They consist of all functions in the global namespace and any functions in user defined namespaces, hence they are called namespace-scope functions.
Member of a class. These are called member functions (even though they are not the only functions that are members!). They can be further separated by non-static member functions and static member functions (I take it you know the difference of this from Java).

Question 4

Think of member function as a method.

In Java, your method (member function) within a class might look something like:

public class MyClass {
    public void MyMethod() {
        // do stuff
    }
}

This is very much the same in C++:

class MyClass
{
    public:
        void MyMethod();
}

As far as how I've been taught, you declare your class and its members in a header file (.h) and then define them in a .cpp file. You don't have to do it that way and can keep everything with your .cpp file. It's just a better practice to separate them.

Question 5

in C++ does not matter ...

member functions are just functions inside class (or struct)

you can have headers
you can also have body only ...
if you separate headers and bodies into *.h(pp) and *.cpp files
then you can cross referencing more classes to each other

here some examples:

class C1
 {
public:
 int a,b,c; // some variables

 void f0();                               // header only
 void f1() { c=a+b; };                  // inline body only
 friend void f2();                      // not a member but can have access to class private things
 friend void f3(C1 &x);                // not a member but can have access to class private things
 };

void C1::f0() { c=a+b; }                // body(C1 member) ... can be in separate file

void f2() { C1 c1; c1.c=c1.a+c1.b; }  // just function not a member
void f3(C1 &x) { x.c=x.a+x.b; }        // just function not a member

if your not member function are accesing only public parts of class then they do not need to be friend.
also there are some restrictions for inline bodies on some compilers
like you can not use asm {} for example...

Question 6

First, your question "Do we have to define it in the header .h file or the .cpp file?"

You can define (write code for) member functions in either, with different implications.

Any function defined in a header file needs to be an inline function (because it will be included to many .cpp files, and being inline means, this is ok). Luckily, if you combine declaration and definition and do it inside class {...}, they are automatically considered inline, so it "just works".

If you define the member function in a .cpp file, then you need to have the declaration inside class {...}. And if you want to use the class from many .cpp files, then it should go to a .h file, but it can also be earlier in the same .cpp file.

More explanation:

Member function is same as method. Also, for the purposes of this answer, function overloads (same name but different arguments, return value is not considered) are different functions.

In C++ there is separate declaration and definition, though they can be rolled into one. Any function is declared by having just ; instead of function body { /* ...code... */ }. If this declaration is inside a class {...} or struct {...}, then it's a member function. A function call is ok in code as long as there's declaration before the call. Then later on linker will complain if there's no actual function definition, that is a block of code to call. There can be any number of declarations for a function, but only one definition (except for inline functions, where compiler and linker assume duplicate definitions are all the same, so they better be or funny things can happen).

About .h and .cpp files: C++ (and C), .h files are eseentially copy-pasted to the .cpp file during compilation. You could remove the #include and copy paste the contents, and it would be exactly same thing for compiler. But from practical standpoint, definitions go to a .h file, and then they are included in may .cpp files, and because they are declarations, it's ok to have them as many times as you like. But actual definitions go to .cpp files, so they get compiled exactly once, so linker is happy.

Finally a bit about inline functions. If you have a member function definition inside class {...}, it is automatically considered to be inline. You include the same .h file with these inline definitions to many .cpp files, but it is ok because they are by default marked inline (and also, since the code is in same .h file, all definitions should be the same, unless you use some #ifdef preprocessor stuff wrong).

Example:

myclass.h

class MyClass {

    void memberFunc1() { 
        // here is function declaration and definition combined, 
        // by default inline, so can be include to many .cpp
    }

    void memberFunc2(); // here's just declaration
}

myclass.cpp

MyClass::memberFunc2() {
    // defintion of member function, not inline, must exist exactly once
}