Link error while compiling a h file containing a struct

You can write like this: first is ProcessStasts.h

#pragma once

#include <mpi.h>
#include <cstddef>

struct ProcessStats
{
    int rank,
    itLeft,
    crtIt,
    processFlag;
    float speed;
};

MPI_Datatype MPI_Cust_ProcessStats_create();

then is ProcessStasts.c

#include "ProcessStats.h"
MPI_Datatype MPI_Cust_ProcessStats_create()
{
    // set data to create new MPI data type
    MPI_Datatype MPI_Cust_ProcessStats;
    MPI_Datatype dataTypes[6] = {MPI_INT, MPI_INT, MPI_INT, MPI_INT, MPI_FLOAT};
    int blockLengths[5] = {1, 1, 1, 1, 1};
    MPI_Aint offsets[5];

    offsets[0] = (MPI_Aint) offsetof(ProcessStats, rank);
    offsets[1] = (MPI_Aint) offsetof(ProcessStats, itLeft);
    offsets[2] = (MPI_Aint) offsetof(ProcessStats, crtIt);
    offsets[3] = (MPI_Aint) offsetof(ProcessStats, processFlag);
    offsets[4] = (MPI_Aint) offsetof(ProcessStats, speed);

    // create new MPI type based on data from above
    MPI_Type_create_struct(3, blockLengths, offsets, dataTypes, &MPI_Cust_ProcessStats);
    MPI_Type_commit(&MPI_Cust_ProcessStats);

    return MPI_Cust_ProcessStats;
}

Then you can include the ProcessStasts.h as many times as you want. As a suggestion, do not define functions in a head file.

#pragma once instructs the preprocessor not to include a header file twice. This is mostly used to prevent recursive inclusions and multiple indirect inclusions, e.g.:

#include <a.h>  // a.h already includes b.h
#include <b.h>

Without #pragma once at the beginning of b.h, its content will get included twice and possibly lead to redefinition of some symbols.

What happens in your case is an entirely different matter. By default functions in C and C++ have external linkage. It means that if you have function foo() defined in file bar.c and then you compile bar.c to the object file bar.o, the object file exports a global symbol by the name of foo (actually C++ will decorate the name in order to support overloading), which symbol can be accessed (referred to) from other object files. Now if file baz.c contains the definition of another function foo() (which in the case of C++ has the same signature), the object file baz.o also exports a global symbol by the name of foo. When the object files get linked together in order to produce an executable file, the linker tries to resolve each symbol to a unique memory address. But now there is a problem: there are two symbols foo and they both have different addresses. The linker is (usually) not a psychic, so it simply gives you an error message about symbol redefinition and terminates.

Both C and C++ provide a mechanism to control the linkage of functions. If you add the static keyword, the function symbol is no longer global and become only visible to the code that shares the same unit of compilation. Such functions have static linkage. That's why functions that are defined in header files almost always come with the static keyword:

#pragma once

#include <mpi.h>
#include <cstddef>

struct ProcessStats
{
    int rank,
    itLeft,
    crtIt,
    processFlag;
    float speed;
};

static MPI_Datatype MPI_Cust_ProcessStats_create()
{
    ...
}

Now MPI_Cust_ProcessStats_create() is only going to be visible in the source file that includes the header file.

Unsolicited advice: The MPI_ prefix is reserved for MPI API calls. Using it for user functions is a bad programming practice since there are tools that rely on the fact that only MPI calls begin with MPI_ and might get confused.