CIS*2750 Lecture 3: List API and Libraries

CIS*2750 Lecture 3: List API, Creating Libraries

• The lecture covers the List API and creating libraries in C.
• Fixed-length arrays are unsuitable for optional data.
• Linked data records are used for flexible data structures.

Review of Simple C Library: List ADT

• Linked lists are a common data structure for optional data.
• Trees and hash tables also utilize linked elements.
• C lacks equivalents to Java's ArrayList or Vector, necessitating linked lists.
• Function pointers are used to manage the list's data (e.g., for freeing and comparing).
• The C List API handles the data as void pointers.

Common List Operations

• Create a list.
• Insert a node at the front or back.
• Remove a node from the front or back.
• Retrieve an arbitrary node.
• Iterate through the list.
• Clear or delete the list.
• Create a human-readable presentation of the list.

Storing Data

• A good data structure should handle any data type.
• Re-declaring a List ADT for every data type is impractical.
• Data is stored as void pointers in C.
• List nodes link to other nodes and the data.

Storing Data (Continued)

• Data types are unknown at compile time.
• Data must be freed carefully (single free call may be insufficient).
• Data must be compared/converted for sorting/insertion (e.g., toString() in Java).
• Functions pointers for freeing and comparing data, along with converting it are in the List structure.

List API in C

• Refer to LinkedListAPI.h in the Week 1-2 examples.
• The example is well-documented.

Iterating through a List

• Iterating through data collection is common.
• Loops with counters are used with indexed collections (like arrays).
• Linked lists use iterators.

Iterators (Example - Java)

• Java code example using ArrayList and an iterator to traverse through the list.

Iterators (Example - C)

• Memory allocation for data is essential.
• malloc is used to allocate memory for each node.
• String data is copied to the allocated memory in the example.
• Demonstrates creation and iteration using the ListIterator.
• List freeing is done by deleteList(list).

Libraries

• Libraries are reusable collections of precompiled functions and ancillary data.

Library Design

• Programmers decide on function components and return values, handling errors, and clear naming conventions.

Libraries in Action

• Standard C libraries provide examples.

Library Design - Public Aspects

• Designing a good API is crucial for the library interface.
• Users interface through predefined functions.

Library Design - Private Aspects

• Internal functionalities are hidden.
• Avoids user errors and modifications.
• This is information hiding (object-oriented programming concept)

Libraries in Practice

• Libraries on Linux are stored in /lib, /usr/lib, /usr/include.
• Associated header files contain constants and function definitions.

Static and Dynamic Libraries

• Static libraries are compiled into the executable.
• Dynamic libraries link during execution.

Static and Dynamic Libraries (Pros/Cons)

• Static libraries make a standalone, but large executable and update is difficult.
• Dynamic libraries are flexible and smaller, but require more user experience and care.

Naming Libraries

• Library names typically start with "lib".
• Static libraries end with ".a".
• Dynamic libraries end with ".so" for Linux and macOS.
• Windows uses ".dll".

Libraries and Symbolic Links

• Symbolic links may create aliases for libraries.
• Example using the math library (libm.so.6) and other common libs.

Creating a Dynamic Library

• Requires two steps: compiling object code and creating the shared library file.
• gcc -fpic for position-independent code.
• gcc -shared for the library creation.

Creating an Executable Using a Shared Library

Steps for producing an executable from source code and a shared library.

Using a Library

• The link step links the library to the compiled program using -l (lowercase L) followed by the library name (e.g., -lxml2).
• Only use the unique name of the library to link with it.