Book Image

Learn C Programming. - Second Edition

By : Jeff Szuhay
Book Image

Learn C Programming. - Second Edition

By: Jeff Szuhay

Overview of this book

The foundation for many modern programming languages such as C++, C#, JavaScript, and Go, C is widely used as a system programming language as well as for embedded systems and high-performance computing. With this book, you'll be able to get up to speed with C in no time. The book takes you through basic programming concepts and shows you how to implement them in the C programming language. Throughout the book, you’ll create and run programs that demonstrate essential C concepts, such as program structure with functions, control structures such as loops and conditional statements, and complex data structures. As you make progress, you’ll get to grips with in-code documentation, testing, and validation methods. This new edition expands upon the use of enumerations, arrays, and additional C features, and provides two working programs based on the code used in the book. What's more, this book uses the method of intentional failure, where you'll develop a working program and then purposely break it to see what happens, thereby learning how to recognize possible mistakes when they happen. By the end of this C programming book, you’ll have developed basic programming skills in C that can be easily applied to other programming languages and have gained a solid foundation for you to build on as a programmer.

Related Content you might be interested in

Current Title:

Small book image
Learn C Programming. - Second Edition
Jeff Szuhay
Aug, 2022 | 742 pages
No titles found
Table of Contents (37 chapters)
Preface
Preface to the Second Edition
Preface to the First Edition
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
Share Your Thoughts
1
Part 1: C Fundamentals
Part 1: C Fundamentals
Free Chapter
2
Chapter 1:Running Hello, World!
Chapter 1:Running Hello, World!
Technical requirements
Writing your first C program
Understanding the program development cycle
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
Learning to experiment with code
Summary
3
Chapter 2: Understanding Program Structure
Chapter 2: Understanding Program Structure
Technical requirements
Introducing statements and blocks
Introducing functions
Understanding function definitions
Order of execution
Understanding function declarations
Summary
Questions
4
Chapter 3: Working with Basic Data Types
Chapter 3: Working with Basic Data Types
Technical requirements
Understanding data types
Bytes and chunks of data
Representing whole numbers
Representing numbers with fractions
Representing single characters
Representing Boolean true/false
Understanding the sizes of data types
Summary
Questions
5
Chapter 4: Using Variables and Assignments
Chapter 4: Using Variables and Assignments
Technical requirements
Understanding data types and values
Introducing variables
Exploring constants
Using types and assignments
Summary
Questions
6
Chapter 5: Exploring Operators and Expressions
Chapter 5: Exploring Operators and Expressions
Technical requirements
Understanding expressions and operations
Introducing operations on numbers
Exploring type conversion
Introducing operations on characters
Order of operations and grouping
Summary
Questions
7
Chapter 6: Exploring Conditional Program Flow
Chapter 6: 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
Summary
Questions
8
Chapter 7: Exploring Loops and Iterations
Chapter 7: Exploring Loops and Iterations
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
Questions
9
Chapter 8: Creating and Using Enumerations
Chapter 8: Creating and Using Enumerations
Technical requirements
Introducing enumerations
The switch()… statement revisited
Using enumerated item values as literal integer constants
Summary
Questions
10
Part 2: Complex Data Types
Part 2: Complex Data Types
11
Chapter 9: Creating and Using Structures
Chapter 9: Creating and Using Structures
Technical requirements
Understanding structures
Performing operations on structures – functions
Structures of structures
The stepping stone to OOP
Summary
Questions
12
Chapter 10: Creating Custom Data Types with typedef
Chapter 10: Creating Custom Data Types with typedef
Technical requirements
Renaming intrinsic types with typedef
Simplifying the use of enum types with typedef
Simplifying the use of struct types with typedef
Exploring some more useful compiler options
Using a header file for custom types and the typedef specifiers
Summary
Questions
13
Chapter 11: Working with Arrays
Chapter 11: Working with Arrays
Technical requirements
Declaring and initializing arrays
Understanding variable-length arrays
Accessing array elements
Operating on arrays with loops
Using functions that operate on arrays
Summary
Questions
14
Chapter 12: Working with Multi-Dimensional Arrays
Chapter 12: Working with Multi-Dimensional Arrays
Technical requirements
Going beyond 1D arrays to multi-dimensional arrays
Declaring and initializing multi-dimensional arrays of various dimensions
Accessing elements of multi-dimensional arrays of various dimensions
Manipulating multi-dimensional arrays using loops within loops
Using multi-dimensional arrays in functions
Summary
Questions
15
Chapter 13: Using Pointers
Chapter 13: Using Pointers
Technical requirements
Addressing pointers – the boogeyman of C programming
Introducing pointers
Declaring the pointer type, naming pointers, and assigning addresses
Operations with pointers
Verbalizing pointer operations
Variable function arguments
Using pointers to structures
Summary
Questions
16
Chapter 14: Understanding Arrays and Pointers
Chapter 14: Understanding Arrays and Pointers
Technical requirements
Understanding array names and pointers
Understanding array elements and pointers
Operations on arrays using pointers
Introducing an array of pointers to arrays
Summary
Questions
17
Chapter 15: Working with Strings
Chapter 15: Working with Strings
Technical requirements
Characters – the building blocks of strings
Exploring C strings
Declaring and initializing a string
Creating and using an array of strings
Common operations on strings – the standard library
Summary
Questions
18
Chapter 16: Creating and Using More Complex Structures
Chapter 16: Creating and Using More Complex Structures
Technical requirements
Introducing the need for complex structures
Revisiting card4.h
Understanding an array of structures
Using a structure with other structures
Using a structure with arrays
Using a structure with an array of structures
Summary
Questions
19
Part 3: Memory Manipulation
Part 3: Memory Manipulation
20
Chapter 17: Understanding Memory Allocation and Lifetime
Chapter 17: Understanding Memory Allocation and Lifetime
Technical requirements
Defining storage classes
Understanding automatic versus dynamic storage classes
Understanding internal versus external storage classes
Exploring the static storage class
Summary
Questions
21
Chapter 18: Using Dynamic Memory Allocation
Chapter 18: Using Dynamic Memory Allocation
Technical requirements
Introducing dynamic memory
Allocating and releasing dynamic memory
Special considerations for dynamic allocation
The linked list dynamic data structure
Pointers to functions
Other dynamic data structures
Summary
Questions
22
Part 4: Input and Output
Part 4: Input and Output
23
Chapter 19: Exploring Formatted Output
Chapter 19: Exploring Formatted Output
Technical requirements
Revisiting printf()
Using format specifiers for unsigned integers
Using format specifiers for signed integers
Using format specifiers for floats and doubles
Using format specifiers for strings and characters
Summary
Questions
24
Chapter 20: Getting Input from the Command Line
Chapter 20: Getting Input from the Command Line
Technical requirements
Revisiting the main() function
Using argc and argv
Summary
Questions
25
Chapter 21: Exploring Formatted Input
Chapter 21: Exploring Formatted Input
Technical requirements
Introducing streams
Reading formatted input with scanf()
Using internal data conversion
Exploring unformatted I/O
Summary
Questions
26
Chapter 22: Working with Files
Chapter 22: Working with Files
Technical requirements
Understanding basic file concepts
Introducing the filesystem essentials
Opening files for reading and writing
Summary
Questions
27
Chapter 23: Using File Input and File Output
Chapter 23: Using File Input and File Output
Technical requirements
File processing
Creating a file of unsorted names
Reading unsorted names and sorting them for output
Summary
Questions
28
Part 5: Building Blocks for Larger Programs
Part 5: Building Blocks for Larger Programs
29
Chapter 24: Working with Multi-File Programs
Chapter 24: Working with Multi-File Programs
Technical requirements
Understanding multi-file programs
Using header files for declarations and source files for definitions
Revisiting the preprocessor
Creating a multi-file program
Building a multi-file program
Summary
Questions
30
Chapter 25: Understanding Scope
Chapter 25: Understanding Scope
Technical requirements
Defining scope – visibility, extent, and linkage
Exploring variable scope
Understanding the block scope of variables
Understanding scope for functions
Summary
Questions
31
Chapter 26: Building Multi-File Programs with Make
Chapter 26: Building Multi-File Programs with Make
Technical requirements
Preparing dealer.c for make
Introducing the make utility
Using macros
Creating rules – targets, dependencies, and actions
A general makefile for simple projects
Going further with make
Summary
Questions
32
Chapter 27:Creating Two Card Programs
Chapter 27:Creating Two Card Programs
Technical requirements
Game one – Blackjack
Game two – One-Handed Solitaire
Summary
33
Epilogue
Epilogue
Taking the next steps
34
Assessments
Assessments
Chapter 2 – Understanding Program Structure
Chapter 3 – Working with Basic Data Types
Chapter 4 – Using Variables and Assignments
Chapter 5 – Exploring Operators and Expressions
Chapter 6 – Exploring Conditional Program Flow
Chapter 7 – Exploring Loops and Iteration
Chapter 8 – Creating and Using Enumerations
Chapter 9 – Creating and Using Structures
Chapter 10 – Creating Custom Data Types with typedef
Chapter 11 – Working with Arrays
Chapter 12 – Working with Multi-Dimensional Arrays
Chapter 13 – Using Pointers
Chapter 14 – Understanding Arrays and Pointers
Chapter 15 – Working with Strings
Chapter 16 – Creating and Using More Complex Structures
Chapter 17 – Understanding Memory Allocation and Lifetime
Chapter 18 – Using Dynamic Memory Allocation
Chapter 19 – Exploring Formatted Output
Chapter 20 – Getting Input from the Command Line
Chapter 21 – Exploring Formatted Input
Chapter 22 – Working with Files
Chapter 23 – Using File Input and File Output
Chapter 24 – Working with Multi-File Programs
Chapter 25 – Understanding Scope
Why subscribe?
35
Other Books You May Enjoy
Other Books You May Enjoy
Packt is searching for authors like you
Share Your Thoughts
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 UTF to Unicode example
The C standard library
Method 1
Method 2
Method 3

Understanding the sizes of data types

As discussed earlier, the number of bytes that a type uses is directly related to the range of values it can hold. Up to this point, this has all been necessarily theoretical. Now, let's write a program to demonstrate what we've been exploring.

While we are focusing exclusively on the C standard, we need to be aware that the standard allows for quite a bit of discretion on the part of any compiler implementor. This is necessary because not all CPUs have the same architecture, nor do they all have the same capabilities. Nor should they. Also, compilers are implemented by humans trying to interpret complex standards documents. Humans, despite our best intentions, might not perfectly conform to the standard.

In this light, it is critical to understand the behavior of your compiler on your system. Here and throughout the book, we emphasize the trust but verify principle so that we are not surprised when things do not work as we expect...

Previous Section
End of Section 9
Next Section