Understanding and Using C Pointers. Core Techniques for Memory Management

(ebook) (audiobook) (audiobook)

Autor:: Richard M Reese

Promocja Przejdź

Understanding and Using C Pointers. Core Techniques for Memory Management Richard M Reese - okladka książki

Understanding and Using C Pointers. Core Techniques for Memory Management Richard M Reese - audiobook MP3

Understanding and Using C Pointers. Core Techniques for Memory Management Richard M Reese - audiobook CD

Wydawnictwo:: O'Reilly Media (Z chęcią przeczytam książkę w języku polskim)
Ocena:: Bądź pierwszym, który oceni tę książkę
Stron:: 226
Dostępne formaty:: ePub

Mobi

Ebook (126,65 zł najniższa cena z 30 dni)

~~149,00 zł~~ (-15%)
126,65 zł

Dodaj do koszyka lub Kup na prezent Kup 1-kliknięciem

(126,65 zł najniższa cena z 30 dni)

Przenieś na półkę

Do przechowalni

Improve your programming through a solid understanding of C pointers and memory management. With this practical book, you’ll learn how pointers provide the mechanism to dynamically manipulate memory, enhance support for data structures, and enable access to hardware. Author Richard Reese shows you how to use pointers with arrays, strings, structures, and functions, using memory models throughout the book.

Difficult to master, pointers provide C with much flexibility and power—yet few resources are dedicated to this data type. This comprehensive book has the information you need, whether you’re a beginner or an experienced C or C++ programmer or developer.

Get an introduction to pointers, including the declaration of different pointer types
Learn about dynamic memory allocation, de-allocation, and alternative memory management techniques
Use techniques for passing or returning data to and from functions
Understand the fundamental aspects of arrays as they relate to pointers
Explore the basics of strings and how pointers are used to support them
Examine why pointers can be the source of security problems, such as buffer overflow
Learn several pointer techniques, such as the use of opaque pointers, bounded pointers and, the restrict keyword

Wybrane bestsellery

Kup polskie wydanie:

Wskaźniki w języku C. Przewodnik

Autor:: Richard Reese

44,90 zł

Druk

Ebook

Ebooka "Understanding and Using C Pointers. Core Techniques for Memory Management" przeczytasz na:

czytnikach Inkbook, Kindle, Pocketbook, Onyx Booxs i innych
systemach Windows, MacOS i innych

systemach Windows, Android, iOS, HarmonyOS
na dowolnych urządzeniach i aplikacjach obsługujących formaty: PDF, EPub, Mobi

Masz pytania? Zajrzyj do zakładki Pomoc »

Audiobooka "Understanding and Using C Pointers. Core Techniques for Memory Management" posłuchasz:

w aplikacji Ebookpoint na Android, iOS, HarmonyOs
na systemach Windows, MacOS i innych

na dowolonych urządzeniach
i aplikacjach obsługujących format MP3
(pliki spakowane w ZIP)

Masz pytania? Zajrzyj do zakładki Pomoc »

Kurs Video "Understanding and Using C Pointers. Core Techniques for Memory Management" zobaczysz:

Oceny i opinie klientów: Understanding and Using C Pointers. Core Techniques for Memory Management Richard M Reese (0) Weryfikacja opinii następuję na podstawie historii zamówień na koncie Użytkownika umieszczającego opinię. Użytkownik mógł otrzymać punkty za opublikowanie opinii uprawniające do uzyskania rabatu w ramach Programu Punktowego.

Szczegóły książki

ISBN Ebooka:: 978-14-493-4455-9, 9781449344559
Data wydania ebooka :: 2013-05-01 Data wydania ebooka często jest dniem wprowadzenia tytułu do sprzedaży i może nie być równoznaczna z datą wydania książki papierowej. Dodatkowe informacje możesz znaleźć w darmowym fragmencie. Jeśli masz wątpliwości skontaktuj się z nami sklep@helion.pl.
Język publikacji:: 1
Rozmiar pliku ePub:: 3.7MB
Rozmiar pliku Mobi:: 8.6MB

Zgłoś erratę
Kategorie:
Programowanie » C - Programowanie

Spis treści książki

Understanding and Using C Pointers
Preface
- Why This Book Is Different
- The Approach
- Audience
- Organization
- Summary
- Conventions Used in This Book
- Using Code Examples
- Safari Books Online
- How to Contact Us
1. Introduction
- Pointers and Memory
  - Why You Should Become Proficient with Pointers
  - Declaring Pointers
  - How to Read a Declaration
  - Address of Operator
  - Displaying Pointer Values
    - Virtual memory and pointers
  - Dereferencing a Pointer Using the Indirection Operator
  - Pointers to Functions
  - The Concept of Null
    - To NULL or not to NULL
    - Pointer to void
    - Global and static pointers
- Pointer Size and Types
  - Memory Models
  - Predefined Pointer-Related Types
    - Understanding size_t
    - Using the sizeof operator with pointers
    - Using intptr_t and uintptr_t
- Pointer Operators
  - Pointer Arithmetic
    - Adding an integer to a pointer
    - Pointers to void and addition
    - Subtracting an integer from a pointer
    - Subtracting two pointers
  - Comparing Pointers
- Common Uses of Pointers
  - Multiple Levels of Indirection
  - Constants and Pointers
    - Pointers to a constant
    - Constant pointers to nonconstants
    - Constant pointers to constants
    - Pointer to (constant pointer to constant)
- Summary
2. Dynamic Memory Management in C
- Dynamic Memory Allocation
  - Memory Leaks
    - Losing the address
    - Hidden memory leaks
- Dynamic Memory Allocation Functions
  - Using the malloc Function
    - To cast or not to cast
    - Failing to allocate memory
    - Not using the right size for the malloc function
    - Determining the amount of memory allocated
    - Using malloc with static and global pointers
  - Using the calloc Function
  - Using the realloc Function
  - The alloca Function and Variable Length Arrays
- Deallocating Memory Using the free Function
  - Assigning NULL to a Freed Pointer
  - Double Free
  - The Heap and System Memory
  - Freeing Memory upon Program Termination
- Dangling Pointers
  - Dangling Pointer Examples
  - Dealing with Dangling Pointers
  - Debug Version Support for Detecting Memory Leaks
- Dynamic Memory Allocation Technologies
  - Garbage Collection in C
  - Resource Acquisition Is Initialization
  - Using Exception Handlers
- Summary
3. Pointers and Functions
- Program Stack and Heap
  - Program Stack
  - Organization of a Stack Frame
- Passing and Returning by Pointer
  - Passing Data Using a Pointer
  - Passing Data by Value
  - Passing a Pointer to a Constant
  - Returning a Pointer
  - Pointers to Local Data
  - Passing Null Pointers
  - Passing a Pointer to a Pointer
    - Writing your own free function
- Function Pointers
  - Declaring Function Pointers
  - Using a Function Pointer
  - Passing Function Pointers
  - Returning Function Pointers
  - Using an Array of Function Pointers
  - Comparing Function Pointers
  - Casting Function Pointers
- Summary
4. Pointers and Arrays
- Quick Review of Arrays
  - One-Dimensional Arrays
  - Two-Dimensional Arrays
  - Multidimensional Arrays
- Pointer Notation and Arrays
  - Differences Between Arrays and Pointers
- Using malloc to Create a One-Dimensional Array
- Using the realloc Function to Resize an Array
- Passing a One-Dimensional Array
  - Using Array Notation
  - Using Pointer Notation
- Using a One-Dimensional Array of Pointers
- Pointers and Multidimensional Arrays
- Passing a Multidimensional Array
- Dynamically Allocating a Two-Dimensional Array
  - Allocating Potentially Noncontiguous Memory
  - Allocating Contiguous Memory
- Jagged Arrays and Pointers
- Summary
5. Pointers and Strings
- String Fundamentals
  - String Declaration
  - The String Literal Pool
    - When a string literal is not a constant
  - String Initialization
    - Initializing an array of char
    - Initializing a pointer to a char
    - Initializing a string from standard input
    - Summary of string placement
- Standard String Operations
  - Comparing Strings
  - Copying Strings
  - Concatenating Strings
- Passing Strings
  - Passing a Simple String
  - Passing a Pointer to a Constant char
  - Passing a String to Be Initialized
  - Passing Arguments to an Application
- Returning Strings
  - Returning the Address of a Literal
  - Returning the Address of Dynamically Allocated Memory
    - Returning the address of a local string
- Function Pointers and Strings
- Summary
6. Pointers and Structures
- Introduction
  - How Memory Is Allocated for a Structure
- Structure Deallocation Issues
- Avoiding malloc/free Overhead
- Using Pointers to Support Data Structures
  - Single-Linked List
  - Using Pointers to Support a Queue
  - Using Pointers to Support a Stack
  - Using Pointers to Support a Tree
  - Summary
7. Security Issues and the Improper Use of Pointers
- Pointer Declaration and Initialization
  - Improper Pointer Declaration
  - Failure to Initialize a Pointer Before It Is Used
  - Dealing with Uninitialized Pointers
- Pointer Usage Issues
  - Test for NULL
  - Misuse of the Dereference Operator
  - Dangling Pointers
  - Accessing Memory Outside the Bounds of an Array
  - Calculating the Array Size Incorrectly
  - Misusing the sizeof Operator
  - Always Match Pointer Types
  - Bounded Pointers
  - String Security Issues
  - Pointer Arithmetic and Structures
  - Function Pointer Issues
- Memory Deallocation Issues
  - Double Free
  - Clearing Sensitive Data
- Using Static Analysis Tools
- Summary
8. Odds and Ends
- Casting Pointers
  - Accessing a Special Purpose Address
  - Accessing a Port
  - Accessing Memory using DMA
  - Determining the Endianness of a Machine
- Aliasing, Strict Aliasing, and the restrict Keyword
  - Using a Union to Represent a Value in Multiple Ways
  - Strict Aliasing
  - Using the restrict Keyword
- Threads and Pointers
  - Sharing Pointers Between Threads
  - Using Function Pointers to Support Callbacks
- Object-Oriented Techniques
  - Creating and Using an Opaque Pointer
  - Polymorphism in C
- Summary
Index
About the Author
Colophon
Copyright