Lecture 8 C Programming: Visibility & Conventions

• Assignment 1 is due on February 07
• Assignment 2 will be out on Friday
• Lab 4 is scheduled for this week

Key Concepts

• Programs can consist of multiple files and millions of code lines, necessitating proper structure and organization
• Encapsulation and abstraction in C rely on programmer conventions and idioms

Programmer Conventions and Practices

• Avoid global variables
• Utilize the static modifier to create simple modules
• Specify interfaces for modules with header files
• Use the void * type to hide implementation details
• These conventions guide modern C development practices

Three Levels of Visibility in C

• Global definitions are visible to any part of the program
• Static definitions are visible only inside the module where defined
• Local definitions are visible only within the function
• Types are compile-time artifacts included where needed
• C does not permit nested functions.
• Visibility for each definition type is:
  • Types are Static and Local
  • Variables are Global, Static, and Local
  • Functions are Global and Static

Global Variables and Functions

• Global entities are accessible by any function
• All functions are global unless designated with a static modifier
• Variables outside a function are global unless specified with static
• Global variables/functions must have unique names to prevent linker errors
• The "extern" modifier must be used

Local Variables and Types

• Local types/variables are defined within a function body
• Local variables are allocated on the program stack
• Large variables, like arrays, should be allocated on the stack
• Local variables exist only during the function call

Static Variables, Functions, and Types

• Static entities are defined and visible only in their file
• Types are static by default without modifiers
• Variables/functions are static if they have the static modifier
• Static variables are initialized to 0 by default

Structures in C

• Structures store multiple values of different types
• When data needs to be grouped together
• Examples are database tables, or contact information
• struct struct_name {} is the syntax

Struct Example

• char name[20];
• char addr[100];
• long long phone;
• } Is how to define an AddrBook structure

Using Pointers With Struct

• structAddrBook t * Con; is the way to point to a structure using memory
• the arrow operator -> is one way to reference the structure memory

Arrays with Struct Type

• Structs support arrays
• To be used with databases
• Consider the AddrBook_t can be used to show multiple addresses
• Similar to a database table holding several addresses

Modules

• A Module is a code file that provides specific functionality while hiding how that functionality is implemented
• It is analogous to a Java class, which has a public interface but private variables and methods

Modules consist of

• A code file that contains; One or more global functions representing the public interface of the module, and static functions and variables that are not part of the public interface
• A header file (of the same name) that contains function declarations of the public interface, and type definitions used by the public interface
• Additionally, a module may use void * type to track instance data

Guards in Header Files

Multiple Inclusion Problem

• Occurs if Node.h defines a struct “node”, Stack.h includes “node.h”, queue.h includes “node.h”
• User.c includes both stack.h and queue.h with struck node defined twice
• C does not allow struct node to be defined twice
• Programmers may not know “node.h” is included by both stack.h and queue.h

Using Guards to Avoid Multiple Inclusion

• Use a guard to ensure header files are only processed once
• The C preprocessor can do conditional preprocessing
• Use the following template: #ifndef HEADER_H #define HEADER_H… #endif
• Using #iffed to only first-time include if HEADER_H

Brief Introduction to Makefiles

• Reduce compile times
• Code files that have not been compiled before
• Code files that have been changed singe the last compile
• Code files that include header have been changed
• Want to automate build with gcc
• Want to use automating using a special file

Makefiles and Make

• A Makefile
  • I a text file
  • Contains rules for how to build a program from its source
  • Created by the developer
  • Read by the make utility
• The make utility
  • Reads in the Makefile
  • Processes the rules
  • Executes the build command in the rules

Makefile Compositions

• Consists of the following 3 sections:
  • Suffixes
  • Marcos -Dependencies / build rules
• Macros are simply variables that store text so do not have duplicate info
• The following from is to dependency: Target: Dependencies, Build Commends

Makefile Tips

• Targte is a file generate from the denpendecies
• Dependencies are 0 or more files that if modified, necessitate recompilation of the target
• Build commands are shell compiles

What does make do?

• Reads in makefile
• Processes macros and dependencies
• The first dependency is the final the final target
• For each dependency:
  • For each of the dependency files compares to the right of the colon
  • Performs the dependencies that specifies how the file is built
• For each pf the dependency files:
  • Checks the dependencies of the file
  • Comparison the target file timestamp
• If the target has to be rebuilt, the build commands are executed

Abstraction and Encapsulation through void *

• Used with multiple stacks
• The functions Take struct node *n as they 1st argument
• Code implementation is hidden

Static Code Analysis - The C Commandments

• Do not put function or variable definitions in header files as the the linker complains about multiple def
• Every code file, except the one containing main() should have a corresponding header file
• All functions and variables that are used outside code file should be declared (not defined) in the corresponding header file
• Initialize all variables especially pointers
• do not use global variables unless an API requires it

Stack Implementation

• Void pop function; will pop a pointer to an item off the stack and return it
• Void push the pointer to an item to item in the stack
• Int empty that returns 1 if empty and 0 if not

Key Points

• C has three levels of visibility: global, static, and local
• Global visibility should be limited to functions
• Organize programs into modules by using the static modifier to reduce visibility of private variables and types
• Use guards in header files to prevent multiple or circular inclusion of header files
• Hide type info by using void to define opaque types
• Makefiles and make are used to automate the build process

Explore C programming conventions for managing code structure, including avoiding global variables and using the static modifier for module creation. Understand the levels of visibility in C: global, static, and local, and how they affect program organization. C relies on programmer conventions and idioms for encapsulation and abstraction.