Understanding Understand Dependencies

When Understand analyzes a project, it creates a database of references between the various parts of the code. These references serve as a connection between two entities.

In the simplest terms let’s say I have two functions:
void foo() { … }
void bar() { … }
Both foo and bar are entities. Things like variables, classes, and structs are all considered an entity. A reference is a link between those entities. For example, if function foo calls function bar, there will be a reference created. The function foo will have a ‘call’ reference to bar and the function bar will have a ‘callby’ reference to foo.

Each relationship that two entities can have, such as one function calling another, or one class inheriting from another has a reference kind. So every time one function calls another function, there will be a ‘call’ and a ‘callby’ reference created between those two functions.

Within Understand, there is a list of these references that are also classified as a dependency. The ‘call’ and ‘callby’ references are one of those that are classified as a dependency. So function foo would depend on the function bar.

Many of these references are languages specific, but here are the references that C/C++ also classifies as dependencies:
“call ~inactive” // bar();
“declare using” //using ParentClass::Class;
“base ~inactive” // struct Derived : Base { … };
“include ~inactive” // #include “file.h”
“modify ~inactive” // i++;
“set ~inactive” // i = j; // i is being set by j
“typed ~inactive” // typedef u_long ulong;
“use ~inactive ~unknown” // i = j; j is use(d) to set i
“using ~inactive ~declare” // using namespace std;
"overrides ~inactive // void foo() override;

Whenever Understand creates one of these references, there is also a dependency that is created as well.