Skip to main content
Engineering LibreTexts

1.8: Standard Libraries

  • Page ID
    29012
  • Overview of Standard Libraries

    A brief explanation of what is being linked to our code, that is, the system's standard libraries, and if necessary we have project specific libraries as well. 

    Many common or standard functions, whose definitions have been written, are ready to be used in any program. They are organized into a group of functions (think of them as several books) and are collectively called a Standard Library There are many function organized into several libraries For example, within C++ many math functions exist and have been coded (and placed into libraries). These functions were written by programmers and tested to insure that they work properly. In most cases the functions were reviewed by several people to double and triple check to insure that they did what was expected. We have the advantage of using these functions with confidence that they will work properly in our programs, thus saving us time and money.

    A main program must establish the existence of functions used in that program. In C++ there is a formal way to:

    • define a function
    • declare a function (a prototype is a declaration to a compiler)
    • call a function

    When we create functions in our program, we usually see them in the following order in our source code listing:

    • declare the function (this is referred to as a prototype of the function)
    • call the function (actually use it in our code)
    • define the function (This is the actual code for the function) 

    When we use functions created by others that have been organized into library, we include a header file in our program which contains the prototypes for the functions. Just like functions that we create, we see them in the following order in our source code listing:

    • declaring the function (prototype provided in the include file)
    • call the function (with parameter passing of values)
    • define the function (it is either defined in the header file or the linker program provides the actual object code from a Standard Library object area)

    In most cases, the user can look at the prototype and understand exactly how the communications (parameter passing) into and out of the function will occur when the function is called. Let's look at the math example of absolute value. The prototype is:

    int abs(int number);

    Not wanting to have a long function name the designers named it: abs instead of "absolute". This might seem to violate the identifier naming rule of using meaningful names, however when identifier names are established for standard libraries they are often shortened to a name that is easily understood by all who would be using them. The function is of data type int, meaning that the function will return an integer value. It is obvious that the integer value returned is the answer to the question, "What is the absolute value of the integer that is being passed into the function". This function is passed only one value; an int number. If I had two integer variables named apple and banana; and I wanted to store the absolute value of banana into apple; then a line of code to call this function would be:

    apple = abs(banana);

    This statement says to pass the function abs the value stored in variable banana and assign the returning value from the function to the variable apple. Thus, if you know the prototype you can usually properly call the function and use its returning value (if it has one) without ever seeing the definition of the code.

    Adapted from: "Standard Libraries" by Kenneth Leroy Busbee is licensed under CC BY 4.0