Replacing C code macros and defining constants in C++ code

Question

Essentials of my problem: My project consists of both C and C++ files, some string constants (they are hardcoded in C part of project with #define) are required to connect to computer via USB, but if I connect two or more of same type devices, they stop responding because those constants are same. Solution to this problem would be assigning those constants dynamically, from C++ files, so that variable from C++ code could reach C part, where those values are used.

What I have now: Values are defined in C headers as #define IDENTIFIER VALUE (hardcoded), where both VALUE is a C primitive constant an int like 0x1234 or char array like "Some string". For instance:

#define IDENTIFIER1 0x1234
#define IDENTIFIER2 0x5678
#define IDENTIFIER3 "Some string"
#define IDENTIFIER4 "Another string"

I know that methods in C use those identifiers with other macros such as LOBYTE and HIBYTE, also values are passed to some functions.

I tried approaching this problem by replacing the string defines with static cast char[] variable definition wrapped in #ifndef, but compiler noted that the identifiers are initializing non-const variables in some functions or is passed as a parameter.

I successfully compiled code in which i changed defining strings from #define IDENTIFIER VALUE to static const unsigned char IDENTIFIER[] = VALUE;, but I still need to define them in C++.

However I struggle to define hexadecimal numbers like 0x1234. I've found other question including something related to my problem, so far I've tried to define hexadecimal values in following ways (found out that uint8_t is just a typedef of unsigned char, also found some questions about casting numbers to unsigned char and some answers to questions about casting types):

static uint8_t IDENTIFIER[] = {0x12, 0x34, 0};

static const uint8_t IDENTIFIER[] = {0x12, 0x34, 0};

static const uint8_t IDENTIFIER[] = (uint8_t*)0x1234;

static const uint16_t identifier_int = 0x1234;
static const unsigned char IDENTIFIER[3] = identifier_int;

there is a function which uses IDENTIFIERs as arguments, its prototype looks like this:

void foo (uint8_t *bar, /*other arguments*/);

and later this is called like that:

foo(IDENTIFIER, /*other arguments*/)

What I want to achieve: Values should be defined in C++ code, where it should use some method to pass those values to C code.

Questions:

1. What is best way to pass values from C++ code to C code? What alternatives there are?

Please inform me if I could increase clarity of my question!

Great thanks to @AhmedMasud for helping me out in defining my problem more clearly and giving few tips to clarify questions.

Answer 1

Values should be defined in C++ code, where it should use some method to pass those values to C code and then define them.

You can certainly do that in a general sense, but making it work with your existing C code will require changes to that code. Those changes could be distinctly non-trivial.

If I understand correctly macros change all places where IDENTIFIER is used to VALUE before compilation,

Yes, that's a reasonably good characterization.

therefore I think that macros shouldn't be used anymore.

I take you to mean that because you want to set values at run time, you cannot use macros. That's quite right. The least disruptive way to accommodate this in your C code would probably be to declare and use external variables to hold the values. Note well, however, that there is a considerable variety of problems that you might need to solve to convert your C code to work that way.

I expect code to look something like

void setIdentifier(identifier)
{
#ifndef IDENTIFIER
static const unsigned char IDENTIFIER[] = identifier;
#endif
}

as far as I know const should already do it.

No, it won't look much like that at all.

In the first place, you said, reasonably, that you don't want to use macros. In that case the #ifndef IDENTIFIER and #endif have no role to play.

In the second place, you have declared variable IDENTIFIER inside a function, so it has no linkage. You need an external variable if you want one function to set it and a different function to read it.

In the third place, since you'll need an external variable, you'll not be able to use an initializer to set its value. If you declare the variable as a char array (as opposed to a char *), then, you'll need to use strcpy() or a similar function to copy the argument's characters into that array. You can use simple assignment for numeric or pointer variables, however.

1. I don't know much about interacting with C code from C++ yet, what is best way to pass values from C++ code to C code? What alternatives there are?

Pretty much the same alternatives you have for passing around values inside C++ code: store the value in an accessible variable, or pass it as a function argument. C has no "methods", but for this purpose, C++ methods can be considered a kind of function.

2. What precautions should I take when assigning those "constants"? I noticed that it is recommended to use static const instead of #define, as mentioned above using macros in this situation probably is unlikely.

The question does not make sense. If you have a constant then you cannot assign a value to it (noting that assigning to is different from initializing). You might use a file-scope const or static const variable if you wanted to set its value at compile time, but the macros in use already accomplish that anyway. Why go to all the work to change?

On the other hand, you need non-const variables if you want to assign to them at runtime. Moreover, you need external variables (non-static) if you want to assign values in one source file that will be read from a different one.

3. Would static const defined in C++ program be seen in C code?

At file / namespace scope, no, because preventing that is the exact purpose of static in that context. Inside a function or method, no, because the local variables of functions / methods are not visible outside the function / method in which they are declared. So, no.

If you want a variable to which one function or method can write and from which another function or method can read, and at least one of the functions accessing the variable is implemented in C, then you need a file-scope external variable. Such a variable is declared to all users (both C and C++) with a file-scope declaration of this form:

/* "extern" is essential */
extern int IDENTIFIER1;

That would normally be placed in a header file that all sources that access the variable include. Additionally, exactly one source file in the project must define the variable, with code of this form:

/*
 * either the initializer or the absence of "extern" is essential;
 * both together is good form.
 */
int IDENTIFIER1 = 0x1234;

Answer 2

I would start with simple replace of macros definitions

#define IDENTIFIER1 0x1234
#define IDENTIFIER2 0x5678
#define IDENTIFIER3 "Some string"
#define IDENTIFIER4 "Another string"

with

const auto IDENTIFIER1 = 0x1234;
const auto IDENTIFIER2 = 0x5678;
const auto IDENTIFIER3 = "Some string";
const auto IDENTIFIER4 = "Another string";

After that I would solve further problems step by step if they occur.