How to Forward-Declare a Function to Avoid 'Nameerror's for Functions Defined Later

How do I forward-declare a function to avoid `NameError`s for functions defined later?

If you don't want to define a function before it's used, and defining it afterwards is impossible, what about defining it in some other module?

Technically you still define it first, but it's clean.

You could create a recursion like the following:

def foo():
    bar()

def bar():
    foo()

Python's functions are anonymous just like values are anonymous, yet they can be bound to a name.

In the above code, foo() does not call a function with the name foo, it calls a function that happens to be bound to the name foo at the point the call is made. It is possible to redefine foo somewhere else, and bar would then call the new function.

Your problem cannot be solved because it's like asking to get a variable which has not been declared.

Forward declare a function/task

Functions and tasks do not need to be declared before use as long as they have a set of trailing parenthesis () which may also include required arguments. They use search rules similar to hierarchical references. See section 23.8.1 Task and function name resolution in the IEEE 1800-2017 SystemVerilog LRM

How to forward declare a template function in global or namespace with default argument?

A default argument, like int i = 0, is seen as a definition. Repeating it is therefore an ODR-violation.

Don't know exactly why, except that the standard explicitly says so

Each of the following is termed a definable item:

[...]

(1.6) a default argument for a parameter (for a function in a given > scope)

[...]
No translation unit shall contain more than one definition of any definable item.

http://eel.is/c++draft/basic.def.odr

The solution is then to only have the default argument appear once, likely in the declaration (and not repeated in the definition).

C: Forward declaring a typedef that will be defined later for being used in declaring a function now

When you do this:

typedef struct IO_link_t IO_link_t;

The typedef defines a type. You're also declaring struct IO_link_t. When you then do this:

typedef struct IO_link_t {
  IO_msg_ptr_t          IO_msg_ptr;
  uint8_t               IO_msg_size;
  IO_logic_ptr_t        IO_logic_ptr;
  //... other members as required by Equipment_setup.h ...
  //... members that vary based on the controller's SDK ...
} IO_link_t;

You define struct IO_link_t which was previously not defined but you also redefine the type IO_link_t. That's where the error comes from. The same goes for the enum.

You can fix this by removing the typedef at the point the struct and enum are defined.

enum IO_devices_t{
  MAIN_CONTROLLER,
  REMOTE_IO_1,
  REMOTE_IO_2,
  //... will vary based on controllers being used...
  HMI_1,
  NUMBER_IO_DEVICES
};

struct IO_link_t {
  IO_msg_ptr_t          IO_msg_ptr;
  uint8_t               IO_msg_size;
  IO_logic_ptr_t        IO_logic_ptr;
  //... other members as required by Equipment_setup.h ...
  //... members that vary based on the controller's SDK ...
};

---

Related Topics