Thanks, I knew there were a few things I forgot.

I extended the exercise to have the calc function called by the loading function and was surprised to find that you don't use the & (if you want it to compile).

Code:

// main.cpp
#include <iostream>
#include <stdio.h>
#include "struct1.h"
#include "extern_funcs.h"

int main(int argc, char**argv) {

   STRUCT1 myStruct1;
   int answer = 0;
   int a, b;
   a = 1; b = 2; 
  
   // call functionto load data into stuct
   load_struct( &myStruct1, a, b, c, d, &answer );

   // print data from struct
   std::cout << "var_a main " << myStruct1.var_a << std::endl;
   std::cout << "var_b main " << myStruct1.var_b << std::endl;

   std::cout << "the answer is " << answer << std::endl;

   return 0;
}

Code:

// load_struct.cpp
#include "struct1.h"
#include "extern_funcs.h"

void load_struct( STRUCT1 *myStruct1, int var_a, int var_b, int *answer ) {

   // load struct with passed data
   myStruct1->var_a = var_a;
   myStruct1->var_b = var_b;

   // call to get answer
   *answer = calc_struct( myStruct1 );

   return;
}

Code:

// calc_struct.cpp
#include <stdio.h>
#include "struct1.h"
#include "extern_funcs.h"

int calc_struct( STRUCT1 *myStruct1 ) {
   int answer;
   // perform calcualtion
   answer = myStruct1->var_a + myStruct1->var_b;
   return answer;
}

Code:

// struct1.h
// structure definition

typedef struct STRUCT1 {
   int var_a;
   int var_b;
} STRUCT1;

Code:

// external_funcs.h
// prototypes for external functions

extern "C" {
   void load_struct( STRUCT1 *myStruct1, int var_a, int var_b, int *answer );
   int calc_struct( STRUCT1 *myStruct1 );
}

The call to load, passing the pointer to myStruct1, is set up as,
load_struct( &myStruct1, a, b, c, d, &answer );

where both myStruct1 and answer are pointers to a var declared in main().

The call to calc seems to be passing the same instance of struct by value,
*answer = calc_struct( myStruct1);

and doesn't compile if you try to pass it as a pointer,
*answer = calc_struct( &myStruct1);

Is that because the compiler already sees the value as pointer, and so would be trying to do **myStruct1? All of the programming I initially learned was in Fortran, where everything is passed as a pointer and there is usually only one way to do most things.

Would this work just as well if the prototypes were absent the extern "C" tag? In the past, I have had a few issues with things in header files where the compiler complained that something was declared in more than one place. I have also has some issues with the linker finding things when the src is spread across multiple src files. I make enough little errors that I can't always be sure if the issue is my choice of method, or its implementation. It appears that it is proper to have struct/class definitions, or function prototypes, in header files that are included in multiple places. Is that correct?

LMHmedchem