LabVIEW gives you the ability to call DLLs written in C and C++ using the Call Library Function Node. The Call Library Function Node allows you to specify the DLL you want to use, the function within the DLL you want to call and allows you to configure the inputs and outputs (parameters and return values) of the function.
The Import Shared Library Wizard can automate a lot of the effort involved in calling C/C++ DLLs by creating wrapper VIs with pre-configured Call Library Function Nodes that you can call from your VIs.
Note: While the Import Shared Library Wizard does very well in creating wrapper VIs for functions that use simple data types and stucts of simple data types, it has some limitations especially relating to:
Confusion between pointers and Arrays: Since arrays technically are simply pointers to the first element in the array, the Import Shared Library cannot tell them apart.
Return Types: Since the Call Library Function Node only allows void, integer and string return types, anything more complex (like structs) must be handled as pointers.
Pointers: Pointers to complex types and pointers returned via return value might not be dereferenced (that is, they will be represented as an integer with a value equal to the memory address pointed to).
These caveats are detailed in the following article. The article also includes examples of how to work around them.
The equivalent for representing structs in LabVIEW is a LabVIEW Cluster. As with structs in C/C++, the ordering of elements in a cluster make a difference, as this is the order in which they are stored in memory. To pass a cluster to a DLL that expects a struct, make sure to order the elements in the cluster in the same order as those in the struct.
Several languages like C and C++ employ the concept of pointers, which is basically a variable that holds (points to) the address (in memory) of the data you are interested in. This is especially prevalent in functions that need to return multiple values. In these cases, programmers use a technique called Call By Reference where the parameters are pointers to the values rather than the actual values.
This can be initially challenging in LabVIEW since LabVIEW hides the concept of pointers and memory allocation from the user, as do several modern languages like C# and Java.
There are ways to pass pointers to C/C++ DLLs, as well as to receive and dereference pointers from C/C++ DLLs in LabVIEW. For details refer to: