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.