调试Visual C++ Windows实战

需积分: 9 107 浏览量更新于2024-07-18 1 收藏 1.81MB PDF 举报

"Debugging Visual C++ Windows" 是一本由 Keith Bugg 撰写的关于调试 Visual C++ 应用程序的专业书籍，主要关注在 Windows 操作系统环境下对 C++ 代码进行调试的技术和策略。这本书可能涵盖了以下几个重要的知识点： 1. **调试基础**：介绍调试的基本概念，包括错误类型、调试器的使用、断点设置、单步执行、变量观察等，帮助读者理解调试过程中的基本操作。 2. **Visual Studio IDE 调试工具**：详细讲解如何利用 Visual Studio 集成开发环境中的调试工具，如 Watch 窗口、Immediate 窗口、Call Stack 窗口等，来分析和定位问题。 3. **内存管理调试**：深入讨论 C++ 中的内存泄漏、野指针等问题，以及如何使用调试器检测和修复这些问题，可能涉及 Heap 分析工具和内存检查工具的使用。 4. **多线程调试**：由于 Windows 平台上的应用程序常常涉及多线程编程，书里可能会涵盖如何调试多线程应用，处理竞态条件、死锁等问题。 5. **异常处理与调试**：介绍 C++ 异常处理机制，以及在调试过程中如何跟踪和处理异常。 6. **调试技巧与最佳实践**：提供实用的调试技巧，如如何有效地复现问题、编写可调试的代码、利用日志记录等，以提高调试效率。 7. **调试特定问题**：可能包括对特定类型的错误或问题（如图形渲染问题、网络通信问题等）的调试方法，以及如何阅读和理解 Windows 错误消息。 8. **调试第三方库和系统调用**：讲解如何调试使用到的第三方库，以及与操作系统交互时遇到的问题，可能包括使用 WinDbg 这样的高级调试工具。 9. **源代码控制与版本管理**：虽然不是直接的调试技术，但源代码管理和版本控制对于追踪问题历史和协作调试至关重要，书中可能提及相关工具和实践。 10. **调试案例研究**：通过实际的案例，展示如何分析和解决复杂的调试问题，帮助读者将理论知识应用到实践中。请注意，由于提供的内容片段不包含具体章节或详细内容，以上知识点是基于标题和描述的通常预期内容。实际书籍可能包含更多细节和具体示例。要获取完整信息，建议直接阅读完整的 "Debugging Visual C++ Windows" 电子书。

< previous page page_x next page >

Page x

As you work through the book, you'll be exposed to a wide variety of bugs and their causes, along with suggested solutions. Known bugs

in the compiler will be given due attention, and you'll find a compendium of resources in the last chapter to help you if you get stuck.

In addition to the subject of debugging, you'll also find some useful hints, tips, and tools to facilitate basic project management. While

some of these topics have no direct relationship to fault detection and isolation, they can indirectly influence your debugging effort.

For example, in Chapter 4, there is a discussion of the pragmas. One useful pragma is

#message(string)

which lets you output a message to the build window. For instance

#message("Date-validation not finished in method GetDate()!");

If you've got a function working that is not completely road-worthy, a reminder like this can save you some embarrassment at product-

delivery time.

Nomenclature

To make this book more readable, I've adopted the following font usage. All functions, API calls, arguments, Windows messages, source

files, modules, and so on are shown in monospaced typeface, matching their counterparts in the code.

I hope this book helps you bring your MFC/Visual C++-based applications to market as quickly and as bug-free as possible.

< previous page page_x next page >

< previous page page_2 next page >

Page 2

effort because errors cost time, money, and can greatly effect current and future sales. With large and complicated

software products, the public has come to accept a certain amount of bugs. But releasing software with bugs beyond the

public's threshold of acceptance makes it all the more difficult to sell new versions and new products.

The Event-Driven Paradigm

Compounding the problem of debugging Windows applications is the simple fact that Windows applications are based

on the model of messages or events. Unlike procedural-based programs that flow in a linear fashion, Windows responds

to messages. Since there is no way of knowing what message will arrive next, you lose the comfort of knowing ''where

to look." For debugging an application based on events, it is essential that the developer know how to use one or more

debugging tools. Mercifully, the Professional Edition of Visual C++ includes several tools, each providing a specialized

function for fault isolation. Forget to delete the memory allocated for a CBrush object? Not to worry the memory

allocation information returned by STRESS.EXE will show you that the GDI heap is shrinking. This at least will point

you in the right direction. Not having tools such as these and the know-how to use them makes debugging Windows

applications an exercise in frustration, if not futility.

The Bug Battle

The war against software bugs can be viewed as three distinct battles:

1. Prevent bugs

2. Detect bugs

3. Resolve or handle bugs

Preventing bugs through proper software design and analysis is the easiest battle to fight the bug never enters the

system. The next two battles the main topic of this book are fought using tools and utilities provided by Visual C++, in

addition to those you can purchase from third-party vendors. Bug detection and resolution can be accomplished by

using these tools and solid, methodical testing. It will be up to your code to detect some program anomalies, whether

they are actual bugs or not. Regardless, it is

< previous page page_2 next page >

< previous page page_3 next page >

Page 3

always good design policy to provide the user with a graceful recovery path from the error or condition.

Error Sources and States

Errors can appear at different places and times in the development cycle, and they must be recognized and sorted into

something manageable. Machine error (which I'll get to shortly) is a classic example if you don't know about it, all the

watch windows and debuggers in the world won't explain why some variable has a value you know is mathematically

wrong.

For our purposes, there are four main types of bugs that can arise during the software development cycle.

1. Machine errors

2. Compile-time errors

3. Run-time errors

4. Logic and design errors

The first type, machine errors, is a topic that many developers seem either not to understand or to discount. The next

two types are, for the most part, easy to detect and correct. The last type, logic and design errors, is much more insidious

because your program will "work" but will produce incorrect and/or unpredictable results. There is no debugger

available for these types of problems; only solid, meticulous design and analysis techniques will help you avoid these

bugs.

Machine Errors

While mainstream pop culture touts the precision of computers, we know it just ain't so. Those little silicon chips

unavoidably create errors some numbers simply can't be accurately expressed. The most common variety of this

condition is called roundoff error. Simply stated, roundoff error is the error produced by not using all the bits of a

binary value. When you use numerical variables in your application, their values are converted to binary numbers. Since

there is always a finite number of bits available for the processor to load or store a number, it "chops off" the end of the

number, and you lose accuracy. The same situation exists for us, because we use a base 10 system of mathematics. Try

dividing 6.0 into 1.0. The answer is 1.66666 . . . the trailing sixes never end.

< previous page page_3 next page >

剩余247页未读，继续阅读

SetZZ

粉丝: 0
资源: 2

调试Visual C++ Windows实战

Debugging Heap Corruption in Visual C++

Ivor Horton’s Beginning Visual C++ 2010 英文版 PDF 超清晰版

visual c ++

VisualStudio 2019 c++ SQL SERVER

windows配置vscode c++环境

visual studio c 教程

Visual Studio 2022怎麽寫驅動

如何用visual studio写C语言

visual Studio2019

vscode配置c++教程(windows)

最新资源