In official Doc. of Python 3, there is a short introduction to embedding Python in another application like C/C++ (seeEmbedding Python in Another Application).

The common procedure is as follows,

1. write prototype C/C++ code and Python module codes.
   Note that in the Python codes conventions of python 2 & 3 can not be mixed together, which may cause segfault when running.

call.c

#include 

int
main(int argc, char *argv[])
{
    PyObject *pName, *pModule, *pDict, *pFunc;
    PyObject *pArgs, *pValue;
    int i;

    if (argc < 3) {
        fprintf(stderr,\"Usage: call pythonfile funcname [args]\\n\");
        return 1;
    }

    Py_Initialize();
    pName = PyUnicode_FromString(argv[1]);
    /* Error checking of pName left out */

    pModule = PyImport_Import(pName);
    Py_DECREF(pName);

    if (pModule != NULL) {
        pFunc = PyObject_GetAttrString(pModule, argv[2]);
        /* pFunc is a new reference */

        if (pFunc && PyCallable_Check(pFunc)) {
            pArgs = PyTuple_New(argc - 3);
            for (i = 0; i < argc - 3; ++i) {
                pValue = PyLong_FromLong(atoi(argv[i + 3]));
                if (!pValue) {
                    Py_DECREF(pArgs);
                    Py_DECREF(pModule);
                    fprintf(stderr, \"Cannot convert argument\\n\");
                    return 1;
                }
                /* pValue reference stolen here: */
                PyTuple_SetItem(pArgs, i, pValue);
            }
            pValue = PyObject_CallObject(pFunc, pArgs);
            Py_DECREF(pArgs);
            if (pValue != NULL) {
                printf(\"Result of call: %ld\\n\", PyLong_AsLong(pValue));
                Py_DECREF(pValue);
            }
            else {
                Py_DECREF(pFunc);
                Py_DECREF(pModule);
                PyErr_Print();
                fprintf(stderr,\"Call failed\\n\");
                return 1;
            }
        }
        else {
            if (PyErr_Occurred())
                PyErr_Print();
            fprintf(stderr, \"Cannot find function \\\"%s\\\"\\n\", argv[2]);
        }
        Py_XDECREF(pFunc);
        Py_DECREF(pModule);
    }
    else {
        PyErr_Print();
        fprintf(stderr, \"Failed to load \\\"%s\\\"\\n\", argv[1]);
        return 1;
    }
    Py_Finalize();
    return 0;
}

multiply.py

def multiply(a,b):
    print(\"Will compute\", a, \"times\", b)
    c = 0
    for i in range(0, a):
        c = c + b
    return c

1. For a single C code, just build like

g++ call.c -o call `python3-config --cflags` `python3-config --ldflags`

This can be written as a shell like build.sh.
3. To run the code, write a shell named run.sh,

PYTHONPATH=. ./call multiply multiply 3 2

Here call is the main code, the two multiplys are the module and function names, respectively.
When running, this code gives,

Will compute 3 times 2
Result of call: 6

Note if no PYTHONPATH=. statement in front of the run command, there will be errors like ImportError: No module named multiply.

Someone suggested to add into the .py file

import sys
sys.path.insert(0, \"./path/to/your/modules/\")

I tested but not helpful.
BTW, the system path can be checked by

import sys
print(sys.path)

Useful commands in Python 3 are:

PyObject *exc_type = NULL, *exc_value = NULL, *exc_tb = NULL;
PyErr_Fetch(&exc_type, &exc_value, &exc_tb);
PyObject* str_exc_type = PyObject_Repr(exc_type); //Now a unicode
object
PyObject* pyStr = PyUnicode_AsEncodedString(str_exc_type, \"utf-8\",
\"Error ~\");
const char *strExcType = PyBytes_AS_STRING(pyStr);
Py_XDECREF(str_exc_type);
Py_XDECREF(pyStr);

Py_XDECREF(exc_type);
Py_XDECREF(exc_value);
Py_XDECREF(exc_tb); 

Other useful tutorials are
Python嵌入C/C++ (Python核心编程)
C++中嵌入Python调用
Embedding Python in C/C++: Part I
Embedding Python in C/C++: Part II