Book Image

Learn C Programming

By : Jeff Szuhay
Book Image

Learn C Programming

By: Jeff Szuhay

Overview of this book

C is a powerful general-purpose programming language that is excellent for beginners to learn. This book will introduce you to computer programming and software development using C. If you're an experienced developer, this book will help you to become familiar with the C programming language. This C programming book takes you through basic programming concepts and shows you how to implement them in C. Throughout the book, you'll create and run programs that make use of one or more C concepts, such as program structure with functions, data types, and conditional statements. You'll also see how to use looping and iteration, arrays, pointers, and strings. As you make progress, you'll cover code documentation, testing and validation methods, basic input/output, and how to write complete programs in C. By the end of the book, you'll have developed basic programming skills in C, that you can apply to other programming languages and will develop a solid foundation for you to advance as a programmer.

Related Content you might be interested in

Current Title:

Small book image
Learn C Programming
Jeff Szuhay
Jun, 2020 | 646 pages
No titles found
Table of Contents (33 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Download the example code files
Download the color images
Conventions used
Get in touch
Reviews
1
Section 1: C Fundamentals
Section 1: C Fundamentals
Free Chapter
2
Running Hello, World!
Running Hello, World!
Technical requirements
Writing your first C program
Hello, world!
Understanding the program development cycle
Edit
Compile
Many C compilers for every OS
A note about IDEs
Installing a compiler on Linux, macOS, or Windows
Run
Verify
Repeat
A note about debugging
Creating, typing, and saving your first C program
Compiling your first C program
Running your first C program
Writing comments to clarify the program later
Some guidelines on commenting code
Adding comments to the Hello, world! program
Learning to experiment with code
Summary
3
Understanding Program Structure
Understanding Program Structure
Technical requirements
Introducing statements and blocks
Experimenting with statements and blocks
Understanding delimiters
Understanding whitespace
Introducing statements
Introducing functions
Understanding function definitions
Exploring function identifiers
Exploring the function block
Exploring function return values
Passing in values with function parameters
Order of execution
Understanding function declarations
Summary
4
Working with Basic Data Types
Working with Basic Data Types
Technical requirements
Understanding data types
Bytes and chunks of data
Representing whole numbers
Representing positive and negative whole numbers
Specifying different sizes of integers
Representing numbers with decimals
Representing single characters
Representing Boolean true/false
Understanding the sizes of data types
The sizeof() operator
Ranges of values
Summary
5
Using Variables and Assignment
Using Variables and Assignment
Technical requirements
Understanding types and values
Introducing variables
Naming variables
Introducing explicit types of variables
Using explicit typing with initialization
Exploring constants
Literal constants
Defined values
Explicitly typed constants
Naming constant variables
Using types and assignment
Using explicit assignment, the simplest statement
Assigning values by passing function parameters
Assignment by the function return value
Summary
6
Exploring Operators and Expressions
Exploring Operators and Expressions
Technical requirements
Expressions and operations
Introducing operations on numbers
Considering the special issues resulting from operations on numbers
Understanding NaN
Understanding underflow NaN
Understanding overflow NaN
Considering precision
Exploring type conversion
Understanding implicit type conversion and values
Using explicit type conversion – casting
Introducing operations on characters
Exploring logical and relational operators
Bitwise operators
The conditional operator
The sequence operator
Compound assignment operators
Multiple assignments in a single expression
Incremental operators
Postfix versus prefix incrementation
Order of operations and grouping
Summary
7
Exploring Conditional Program Flow
Exploring Conditional Program Flow
Technical requirements
Understanding conditional expressions
Introducing the if()… else… complex statement
Using a switch()… complex statement
Introducing multiple if()… statements
Using nested if()… else… statements
The dangling else… problem
Summary
8
Exploring Loops and Iteration
Exploring Loops and Iteration
Technical requirements
Understanding repetition
Understanding brute-force repetition
Introducing the while()… statement
Introducing the for()… statement
Introducing the do … while() statement
Understanding loop equivalency
Understanding unconditional branching – the dos and (mostly) don'ts of goto
Further controlling loops with break and continue
Understanding infinite loops
Summary
9
Creating and Using Enumerations
Creating and Using Enumerations
Technical requirements
Introducing enumerations
Defining enumerations
Using enumerations
The switch()… statement revisited
Summary
10
Section 2: Complex Data Types
Section 2: Complex Data Types
11
Creating and Using Structures
Creating and Using Structures
Technical requirements
Understanding structures
Declaring structures
Initializing structures and accessing structure elements
Performing operations on structures – functions
Structures of structures
Initializing structures with functions
Printing a structure of structures – reusing functions
The stepping stone to object-oriented programming
Summary
12
Creating Custom Data Types with typedef
Creating Custom Data Types with typedef
Technical requirements
Renaming intrinsic types with typedef
Using synonyms
Simplifying the use of enum types with typedef
Simplifying the use of struct types with typedef
Other uses of typedef
Some more useful compiler options
Using a header file for custom types and the typedef specifiers
Summary
13
Working with Arrays
Working with Arrays
Technical requirements
Declaring and initializing arrays
Initializing arrays
Accessing array elements
Assigning values to array elements
Operating on arrays with loops
Using functions that operate on arrays
Summary
14
Working with Multi-Dimensional Arrays
Working with Multi-Dimensional Arrays
Technical requirements
Going beyond one-dimensional arrays to multi-dimensional arrays
Revisiting one-dimensional arrays
Moving on to two-dimensional arrays
Moving on to three-dimensional arrays
Considering N-dimensional arrays
Declaring and initializing multi-dimensional arrays
Declaring arrays of two dimensions
Initializing arrays of two dimensions
Declaring arrays of three dimensions
Initializing arrays of three dimensions
Declaring and initializing arrays of N dimensions
Accessing elements of multi-dimensional arrays
Manipulating multi-dimensional arrays – loops within loops
Using nested loops to traverse a two-dimensional array
Using nested loops to traverse a three-dimensional array
Using multi-dimensional arrays in functions
Summary
15
Using Pointers
Using Pointers
Technical requirements
Addressing pointers – the boogeyman of C programming
Why use pointers at all?
Introducing pointers
Understanding direct addressing and indirect addressing
Understanding memory and memory addressing
Managing and accessing memory
Exploring some analogies in the real world
Declaring the pointer type, naming pointers, and assigning addresses
Declaring the pointer type
Naming pointers
Assigning pointer values (addresses)
Operations with pointers
Assigning pointer values
Differentiating between the NULL pointer and void*
Understanding the void* type
Accessing pointer targets
Pointer arithmetic
Comparing pointers
Verbalizing pointer operations
Variable function arguments
Passing values by reference
Passing addresses to functions without pointer variables
Pointers to pointers
Using pointers to structures
Accessing structures and their elements via pointers
Using pointers to structures in functions
Summary
16
Understanding Arrays and Pointers
Understanding Arrays and Pointers
Technical requirements
Understanding array names and pointers
Understanding array elements and pointers
Accessing array elements via pointers
Operations on arrays using pointers
Using pointer arithmetic
Using the increment operator
Passing arrays as function pointers revisited
Interchangeability of array names and pointers
Introducing an array of pointers to arrays
Summary
17
Working with Strings
Working with Strings
Technical requirements
Characters – the building blocks of strings
The char type and ASCII
Beyond ASCII – UTF-8 and Unicode
Operations on characters
Getting information about characters
Manipulating characters
Exploring C strings
An array with a terminator
Strengths of C strings
Weaknesses of C strings
Declaring and initializing a string
String declarations
Initializing strings
Passing a string to a function
Empty strings versus null strings
Hello, World! revisited
Creating and using an array of strings
Common operations on strings – the standard library
Common functions
Safer string operations
Summary
18
Creating and Using More Complex Structures
Creating and Using More Complex Structures
Technical requirements
Introducing the need for complex structures
Revisiting card4.h
Understanding an array of structures
Creating an array of structures
Accessing structure elements within an array
Manipulating an array of structures
Using a structure with other structures
Creating a structure consisting of other structures
Accessing structure elements within the structure
Manipulating a structure consisting of other structures
Using a structure with arrays
Understanding randomness and random number generators
Creating a structure with an array
Accessing array elements within a structure
Manipulating array elements within a structure
Revisiting the hand structure
Revisiting hand operations
Using a structure with an array of structures
Creating a structure with an array of structures
Accessing individual structure elements of the array within a structure
Manipulating a structure with an array of structures
Completing carddeck.c
Revisiting the deck structure
Revisiting deck operations
A basic card program
Summary
19
Section 3: Memory Manipulation
Section 3: Memory Manipulation
20
Understanding Memory Allocation and Lifetime
Understanding Memory Allocation and Lifetime
Technical requirements
Defining storage classes
Understanding automatic versus dynamic storage classes
Automatic storage
Dynamic storage
Understanding internal versus external storage classes
Internal or local storage classes
External or global storage classes
The lifetime of automatic storage
Exploring the static storage class
Internal static storage
External static storage
The lifetime of static storage
Summary
21
Using Dynamic Memory Allocation
Using Dynamic Memory Allocation
Technical requirements
Introducing dynamic memory
A brief tour of C's memory layout
Allocating and releasing dynamic memory
Allocating dynamic memory
Releasing dynamic memory
Accessing dynamic memory
The lifetime of dynamic memory
Special considerations for dynamic allocation
Heap memory management
Memory leaks
The linked list dynamic data structure
Linked list structures
Declaring operations on a linked list
Pointers to functions
More complex operations on a linked list
A program to test our linked list structure
Other dynamic data structures
Summary
22
Section 4: Input and Output
Section 4: Input and Output
23
Exploring Formatted Output
Exploring Formatted Output
Technical requirements
Revisiting printf()
Understanding the general format specifier form
Using format specifiers for unsigned integers
Using unsigned integers in different bases
Considering negative numbers as unsigned integers
Exploring powers of 2 and 9 in different bases
Printing pointer values
Using format specifiers for signed integers
Using the signed integer field width, precision, alignment, and zero-filling
Formatting long-long integers
Powers of 2 and 9 with different modifiers
Using format specifiers for floats and doubles
Using the floating-point field width, precision, alignment, and zero-filling
Printing doubles in hexadecimal format
Printing optimal field widths for doubles
Using format specifiers for strings and characters
Using the string field width, precision, alignment, and zero-filling
Exploring the sub-string output
Using single character formatting
Summary
24
Getting Input from the Command Line
Getting Input from the Command Line
Technical requirements
Revisiting the main() function
The special features of main()
The two forms of main()
Using argc and argv
A simple use of argc and argv
Command-line switches and command-line processors
Summary
25
Exploring Formatted Input
Exploring Formatted Input
Technical requirements
Introducing streams
Understanding the standard output stream
Understanding the standard input stream
Revisiting the console output with printf() and fprintf()
Exploring the console input with scanf()
Reading formatted input with scanf()
Reading numerical input with scanf()
Reading string and character input with scanf()
Using a scan set to limit possible input characters
Controlling the scanf() input field width
Using internal data conversion
Using sscanf() and sprintf() to convert values into and from strings
Converting strings into numbers with atoi() and atod()
Exploring unformatted input and output
Getting the string input and output to/from the console
Using the simple input and output of strings with gets() and puts()
Understanding why using gets() could be dangerous
Creating a sorted list of names with fgets() and fputs()
Summary
26
Working with Files
Working with Files
Technical requirements
Understanding basic file concepts
Revisiting file streams
Understanding the properties of the FILE streams
Opening and closing a file
Understanding file operations for each type of stream
Introducing the filesystem essentials
Introducing the filesystem
Understanding a file path
Understanding a filename
Opening files for reading and writing
Getting filenames from within the program
Getting filenames from the command line
Summary
27
Using File Input and File Output
Using File Input and File Output
Technical requirements
File processing
Creating a template program to process filenames given on the command line
Creating a file of unsorted names
Trimming the input string from fgets()
Reading names and writing names
Reading unsorted names and sorting them for output
Using a linked list to sort names
Writing names in sorted order
Summary
28
Section 5: Building Blocks for Larger Programs
Section 5: Building Blocks for Larger Programs
29
Working with Multi-File Programs
Working with Multi-File Programs
Technical requirements
Understanding multi-file programs
Using header files for declarations and source files for definitions
Creating source files
Creating header files
Revisiting the preprocessor
Understanding the limits and dangers of the preprocessor
Knowing some dangers of the preprocessor
Using the preprocessor effectively
Debugging with the preprocessor
Creating a multi-file program
Extracting Card structures and functions
Extracting Hand structures and functions
Extracting Deck structures and functions
Finishing the dealer.c program
Building a multi-file program
Summary
30
Understanding Scope
Understanding Scope
Technical requirements
Defining scope – visibility, extent, and linkage
Exploring visibility
Exploring extent
Exploring linkage
Understanding compilation units
Putting visibility, extent, and linkage all together
Exploring variable scope
Understanding the block scope of variables
Understanding function parameter scope
Understanding file scope
Understanding global scope
Understanding function scope
Understanding scope and information hiding
Using the static specifier for functions
Summary
Epilog
Taking the next steps
More advanced C topics
More advanced programming topics
Picking a project for yourself
Resources
31
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think
Appendix
C definition and keywords
C keywords
Table of operators and their precedence
Summary of useful GCC and Clang compiler options
ASCII character set
The Better String Library (Bstrlib)
A quick introduction to Bstrlib
A few simple examples
Unicode and UTF-8
A brief history
Where we are today
Moving from ASCII to UTF-8
A UTF-to-Unicode example
The C standard library
Method 1
Method 2
Method 3
Preface

Learning to program is the process of learning to solve problems with a computer. Your journey in gaining this knowledge will be long and arduous with unexpected twists and turns, yet the rewards of this journey, both small and large, are manyfold. Initial satisfaction comes when you get your program to work and to give the correct results. Satisfaction grows as you are able to solve larger and more complex problems than you ever thought possible.

The beginning of your journey is learning a programming language. This book primarily addresses that beginning: learning a programming language, in this case, C. The first step in learning a programming language is to learn its syntax. This means understanding and memorizing important keywords, punctuation, and the basic building blocks of program structure.

The approach taken in Learn C Programming is intended to give you the tools, methods, and practices you need to help you minimize the frustrations you will encounter. Every program provided is a complete, working program using modern C syntax. The expected output for each program is also provided.

Learning to program is especially frustrating because there are so many moving parts. By this, I mean that every aspect of the programming process has changed over time and will continue to change in the future. Computer hardware and operating systems will evolve to meet new uses and challenges. Computer languages will also evolve and change to remove old language deficiencies as well as to adapt to solving new problems. The programming practices and methods used today will change as languages evolve. The kinds of problems that need to be solved will also change as people use computers for different uses.And lastly, you will change. As you use a programming language, it will change the way you think about problems. As problems and solutions change, so does our thinking about what will become possible. This leads to changes in computer language. It's a never-ending cycle.

C has evolved considerably from the language first developed by Denis Ritchie in the early 1970s. It was extremely simple yet powerful enough to develop early versions of the Unix operating system at Bell Labs. Those early versions of C were not for novice programmers. Those versions required advanced knowledge and programming skills in order to make programs robust and stable. Over the years, as C compilers became much more widely available, there have been several efforts to rein in unrestricted and sometimes dangerous language features. The first was ANSI C, codified in 1989. The next major refinement came with C99, codified in 1999; it included significant language additions and clarified many C behaviors. Since then, two additional revisions have been made, C11 and C18, both of which have focused on minor language additions and internal corrections to the language.

C today is much more constrained and complex than the early versions of C. Yet it retains its power, performance, and suitability to a wide range of computing problems. This book strives to present the most current syntax and concepts as specified in C99, C11, and C18. Each program has been compiled and run using the C11 standard. As time goes on, C18 compliance will be much more widespread than today. I would expect, however, that all of these programs will compile and run as intended using the C18 standard.

There will always be more to learn, even without the parts moving. After reading Learn C Programming, you will find a particular way to make C work for you. As you gain experience solving problems with C, you will discover new things—features, uses, and limitations—about C that you didn't see before. So, we can say that learning to program is as much about learning how to learn as it is about solving problems with programs.

Along the way, you will learn about other programming concepts not directly tied to the C. The general development cycle will not only be discussed but will also be illustrated in the development of a card dealing program. While you may not be interested in cards, pay particular attention to the process of how this program is developed. Throughout, the basic practices of experimentation and validation will be illustrated.

Previous Section
Next Section