// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

// For compilers that support precompilation, includes "wx/wx.h".
#include <string>
#include <iostream>
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

// for all others, include the necessary headers (this file is usually all you
// need because it includes almost all "standard" wxWidgets headers)
#ifndef WX_PRECOMP
    #include "wx/wx.h"
#endif
// ----------------------------------------------------------------------------
// resources
// ----------------------------------------------------------------------------

// the application icon (under Windows and OS/2 it is in resources and even
// though we could still include the XPM here it would be unused)
#if !defined(__WXMSW__) && !defined(__WXPM__)
    #include "sample.xpm"
#endif

// ----------------------------------------------------------------------------
// private classes
// ----------------------------------------------------------------------------

// Define a new application type, each program should derive a class from wxApp
class MyApp : public wxApp
{
public:
    // override base class virtuals
    // ----------------------------

    // this one is called on application startup and is a good place for the app
    // initialization (doing it here and not in the ctor allows to have an error
    // return: if OnInit() returns false, the application terminates)
    virtual bool OnInit();
};

// Define a new frame type: this is going to be our main frame
class MyFrame : public wxFrame
{
public:
    // ctor(s)
    MyFrame(const wxString& title);
 wxButton *WxButton1;
    wxTextCtrl *wxTextCtrl1;
        wxTextCtrl *wxTextCtrl2;
    // event handlers (these functions should _not_ be virtual)
    void OnQuit(wxCommandEvent& event);
    void OnAbout(wxCommandEvent& event);
void WxButton1Click(wxCommandEvent& event);
private:
    // any class wishing to process wxWidgets events must use this macro
    DECLARE_EVENT_TABLE()
};

// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------

// IDs for the controls and the menu commands
enum
{
 ID_WXBUTTON1 = 1001,
    // menu items
   
    Minimal_Quit = wxID_EXIT,

    // it is important for the id corresponding to the "About" command to have
    // this standard value as otherwise it won't be handled properly under Mac
    // (where it is special and put into the "Apple" menu)
    Minimal_About = wxID_ABOUT

};

// ----------------------------------------------------------------------------
// event tables and other macros for wxWidgets
// ----------------------------------------------------------------------------

// the event tables connect the wxWidgets events with the functions (event
// handlers) which process them. It can be also done at run-time, but for the
// simple menu events like this the static method is much simpler.
BEGIN_EVENT_TABLE(MyFrame, wxFrame)
    EVT_MENU(Minimal_Quit,  MyFrame::OnQuit)
    EVT_MENU(Minimal_About, MyFrame::OnAbout)
    EVT_BUTTON(ID_WXBUTTON1,MyFrame::WxButton1Click)
END_EVENT_TABLE()

// Create a new application object: this macro will allow wxWidgets to create
// the application object during program execution (it's better than using a
// static object for many reasons) and also implements the accessor function
// wxGetApp() which will return the reference of the right type (i.e. MyApp and
// not wxApp)
IMPLEMENT_APP(MyApp)

// ============================================================================
// implementation
// ============================================================================

// ----------------------------------------------------------------------------
// the application class
// ----------------------------------------------------------------------------

// 'Main program' equivalent: the program execution "starts" here
bool MyApp::OnInit()
{
    // create the main application window
    MyFrame *frame = new MyFrame(_T("helloworld-test"));

    // and show it (the frames, unlike simple controls, are not shown when
    // created initially)
    frame->Show(true);

    // success: wxApp::OnRun() will be called which will enter the main message
    // loop and the application will run. If we returned false here, the
    // application would exit immediately.
    return true;
}

// ----------------------------------------------------------------------------
// main frame
// ----------------------------------------------------------------------------

// frame constructor
MyFrame::MyFrame(const wxString& title)
       : wxFrame(NULL, wxID_ANY, title)
{

    // set the frame icon
    SetIcon(wxICON(sample));

#if wxUSE_MENUS
    wxMenu *fileMenu = new wxMenu;
    wxMenu *helpMenu = new wxMenu;
    helpMenu->Append(Minimal_About, _T("&About...\tF1"), _T("Show about dialog"));

    fileMenu->Append(Minimal_Quit, _T("E&xit\tAlt-X"), _T("Quit this program"));

    wxMenuBar *menuBar = new wxMenuBar();
    menuBar->Append(fileMenu, _T("&系统"));
    menuBar->Append(helpMenu, _T("&帮助"));

    // ... and attach this menu bar to the frame
    SetMenuBar(menuBar);
  
#endif // wxUSE_MENUS

#if wxUSE_STATUSBAR
    // create a status bar just for fun (by default with 1 pane only)
    CreateStatusBar(2);
    SetStatusText(_T("helloworld-test"));
#endif // wxUSE_STATUSBAR
 wxPanel* p = new wxPanel(this, -1);
   wxBoxSizer *topsizer = new wxBoxSizer( wxVERTICAL );
   
   
/*    topsizer->Add(
    new wxStaticText( p, wxID_ANY, _T("An explanation (wxALIGN_RIGHT).") ),
    wxSizerFlags().Align(wxALIGN_RIGHT).Border(wxALL & ~wxBOTTOM, 5));

  topsizer->Add(
    new wxTextCtrl( p, wxID_ANY, _T("My text (wxEXPAND)."), wxDefaultPosition, wxSize(100,60), wxTE_MULTILINE),
    wxSizerFlags(1).Expand().Border(wxALL, 5));

  wxBoxSizer *statsizer = new wxStaticBoxSizer(
    new wxStaticBox(p, wxID_ANY, _T("A wxStaticBoxSizer")), wxVERTICAL );
  statsizer->Add(
    new wxStaticText(p, wxID_ANY, _T("And some TEXT inside it")),
    wxSizerFlags().Center().Border(wxALL, 30));
  topsizer->Add(
    statsizer,
    wxSizerFlags(1).Expand().Border(wxALL, 10));*/
   
   
    wxGridSizer *gridsizer = new wxGridSizer(2, 5, 5);
   
    gridsizer->Add(new wxStaticText(p, wxID_ANY, _T("Label")),
                   wxSizerFlags().Align(wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL));
                   wxTextCtrl1 = new wxTextCtrl(p, wxID_ANY, _T(""));
    gridsizer->Add(wxTextCtrl1,
                   wxSizerFlags(1).Align(wxGROW | wxALIGN_CENTER_VERTICAL));
    gridsizer->Add(new wxStaticText(p, wxID_ANY, _T("Another label")),
                   wxSizerFlags().Align(wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL));
                  
                   wxTextCtrl2 = new wxTextCtrl(p, wxID_ANY, _T(""));
                  
    gridsizer->Add(wxTextCtrl2,
                   wxSizerFlags(1).Align(wxGROW | wxALIGN_CENTER_VERTICAL));
    gridsizer->Add(new wxStaticText(p, wxID_ANY, _T("Final label")),
                   wxSizerFlags().Align(wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL));
    gridsizer->Add(new wxTextCtrl(p, wxID_ANY, _T("")),
                   wxSizerFlags().Align(wxGROW | wxALIGN_CENTER_VERTICAL));
     topsizer->Add(
        gridsizer,
        wxSizerFlags().Proportion(1).Expand().Border(wxALL, 10));
       
     wxBoxSizer *button_box = new wxBoxSizer( wxHORIZONTAL );
  button_box->Add(
     new wxButton( p, wxID_ANY, _T("Two buttons in a box") ),
     wxSizerFlags().Border(wxALL, 7));
    
 
   WxButton1 = new wxButton(p, ID_WXBUTTON1, _T("WxButton1"), wxPoint(142,184), wxSize(75,25), 0, wxDefaultValidator, wxT("WxButton1"));
 
       button_box->Add(WxButton1,  wxSizerFlags().Border(wxALL, 7));
  button_box->Add(
     new wxButton( p, wxID_ANY, _T("(wxCENTER)") ),
     wxSizerFlags().Border(wxALL, 7));

  topsizer->Add(button_box, wxSizerFlags().Center());

  p->SetSizer( topsizer );
 

      topsizer->SetSizeHints( this );
   

}

// event handlers

void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
{
    // true is to force the frame to close
    Close(true);
}

void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
{
    wxString msg;
    msg.Printf( _T("helloworld-test.\n")
                _T("helloworld-test"));
               

    wxMessageBox(msg, _T("About Minimal"), wxOK | wxICON_INFORMATION, this);
}
void MyFrame::WxButton1Click(wxCommandEvent&  WXUNUSED(event))
{
 

 wxString n1 = wxTextCtrl1->GetValue();
 wxString n2 = wxTextCtrl1->GetValue();
 std::string nx = (std::string)n1;
 std::cout << nx <<std::endl;
 wxString msg;
 msg.Printf( _T(n1));

    wxMessageBox(msg, _T("About Minimal"), wxOK | wxICON_INFORMATION, this);
}

--------------------------------------------------------------------
Getting Started with MinGW and MSYS
(based on contribution by Michael J. Pedersen, 2004-08-17)

MSYS is a Unix-like environment for Windows.  Once you have this installed,
building libpqxx should be a lot more like it is under Unix except that the
locations of libraries and such aren't sufficiently standardized.

Packages to download if you don't have them already:
1) MinGW (http://www.mingw.org/), plus any updates.
2) MSYS (http://www.mingw.org/), again with any updates.
3) w32api (http://www.mingw.org/).
4) PostgreSQL (http://www.postgresql.org/).
5) zlib (http://www.zlib.org/).

It is generally recommended to get the latest versions of these packages.

Compiling and installing PostgreSQL before you get to libpqxx:
1) Install MinGW (install to c:\mingw)
2) Install MSYS--but not into MinGW directory tree!
3) Run MSYS (Start->Programs->MinGW->MSYS->msys)
4) Extract, compile, and install zlib
    # From main source directory of zlib:
    ./configure --prefix=c:/mingw/local && make && make install
5) Extract, compile, and install postgres
    # From main source directory of PostgreSQL:
    ./configure --prefix=c:/mingw/local --with-includes=c:/mingw/local/include --with-libs=c:/mingw/local/lib  && make && make install
   重要:把C:\mingw\local\bin设置环境变量PATH中
6) Extract, compile, and install libpqxx
    export LDFLAGS=-lws2_32 &&  ./configure --prefix=c:/mingw/local --disable-shared --enable-static --disable-thread-safety && make && make install
---------------------------------------------------------------------
   
 Uing it in eclpise cdt
 1、设置环境变量PATH C:\mingw\local\lib 使程序能连接到libpq.dll
 2、 -I "C:\MinGW\local\include"
  -I "C:\MinGW\libpqxx-2.5.5\include"
 3、 -l  
   pqxx
   pq
   ws2_32
   wsock32
   注意顺序
  -L 
   "C:\MinGW\local\lib"
   "C:\MinGW\lib"
 4、测试代码
 pqlib C库 \postgresql-8.1.3\src\test\examples
 pqlibxx C++ libpqxx-2.5.5\test    

4 downloads wxWidgets-2.6.3.zip from http://www.wxwidgets.org/ 
4.1 building it
 unzip it first say:D:\MinGW\wxWidgets-2.6.3
 > cd D:\MinGW\wxWidgets-2.6.3\build\msw
   > make -f makefile.gcc BUILD=release
   > cd D:\MinGW\wxWidgets-2.6.3\samples\minimal
   > make -f makefile.gcc BUILD=release
4.2 use wxWidgets-2.6.3 in eclipse
 Properties for a c++ project
 GCC C++ Compiler
  Preprocessor(-D)  _WINDOWS
     WIN32
     __WIN95__
  Directories  "D:\MinGW\lib\gcc-lib\mingw32\3.2.3\include"
     "D:\MinGW\wxWidgets-2.6.3\include"
     "D:\MinGW\wxWidgets-2.6.3\lib\gcc_lib\msw"
 GCC C++ Linker
  Libraries
   Libraries(-l)
    wxmsw26_adv
    wxmsw26_core
    wxbase26
    wxtiff
    wxjpeg
    wxpng
    wxzlib
    wxregex
    wxexpat
    kernel32
    user32
    gdi32
    comdlg32
    winspool
    winmm
    shell32
    comctl32
    ole32
    oleaut32
    uuid
    rpcrt4
    advapi32
    wsock32
    odbc32
   Library search path(-L)
    "D:\MinGW\lib"
    "D:\MinGW\wxWidgets-2.6.3\lib\gcc_lib"

5 Install some libs tools on eclpise
ACE_wrappers build with Msys  http://www.cs.wustl.edu/~schmidt/ACE.html
mysql++-2.1.1 build with makefile and need the mysql source src zip file http://www.tangentsoft.net/mysql++/ 
STLport-4.6.2 http://stlport.org
STLsgi-3.3 http://www.sgi.com/tech/stl
boost_1_33_1   http://www.boost.org/

look the readme file will help you build

http://www.freebyte.com/programming/cpp/

第一章     概述
1.计算机由运算器、存储器、控制器和输入/输出五个部件组成。
2.冯·诺依曼计算机的主要特点：
1）计算机由运算器、存储器、控制器和输入/输出五个部件组成。
2）存储器以二进制形式存储指令和数据；
3）存储程序工作方式；
4）五部件以运算器为中心进行组织；

第2章  数据的表示
1.在计算机系统中，凡是要进行处理（包括计算、查找、排序、分类、统计、合并等）、存储和传输的信息，都是用二进制进行编码的。
2.进位计数制及其各进位制数之间的转换
3.定点与浮点表示的方法、特点
4.机器数的三种编码表示方式：原码、补码和反码。     定义、特点、用途。
5.浮点数的编码表示及规格化
6.十进制数的二进制编码表示即 BCD码的特点
7.字符及汉字的编码方法、特点
8.音频、视频的编码方法及特点
9.数据校验码的用途

第3章 运算器与运算方法
1. 运算器基本组成和功能
2.半加器与全加器的逻辑设计
3.串行进位与并行进位的比较
4.补码定点加、减法
5.原码一位乘法
6.补码一位乘法
7.浮点加、减法

第4章  存储系统
1.存储器的主要性能指标
2.存储系统的层次结构
3.半导体读写存储器RAM芯片的结构、组成及存储器系统的构成
4.半导体只读存储器的特点及分类
5.高速缓冲存储器Cache的工作原理、映射方式、替换算法，了解Pentium Cache 结构和Power PC Cache 结构。
. 虚拟存储器的功能、基本管理方法、结构7.磁表面存储器的性能指标、硬磁盘存储器的基本组成、信息分布、硬盘容量和数据传输率的计算

第5章  指令系统
1. 指令格式、指令长度
2.常用的寻址方式种类、特点、用途
3.指令系统的地位、作用，指令类型
4.堆栈的定义、用途和堆栈存取方式
5. CISC与RISC指令各自的特点和比较

第6章  中央处理机组织
1. CPU的组成与操作（单总线组织的数据通路及四种基本功能。
2.控制器三种时序控制方式：同步、异步和联合控制方式。
3.三种时序信号周期、节拍和脉冲的概念、作用
4.控制器的组成和功能
5.一条完整指令执行的控制步序列
6.决定CPU性能最重要的三个因素：指令的功能强弱、时钟周期的长短、执行每条指令所需时钟周期数。
7.指令流水的概念
8.组合逻辑控制器的构成与设计步骤
9.微程序控制器的原理、基本概念、基本组织和工作流程
10.微指令的两种格式与3种编码
11.两种微指令地址的生成方法
12.微程序控制器和组合逻辑控制器的比较

第7章  总线及总线互连结构
1.总线的基本概念、作用和分类
2.总线的两种传输方式--串行和并行的特点
3.总线裁决的意义及分类
4.总线定时方式的分类及特点
5.影响总线带宽的因素
6.单总线结构和多总线分层结构的比较

第8章  输入输出设备

第9章 输入输出组织
1. I/O接口的功能、结构和分类
2. I/O端口编址的两种方法的比较
3. 四种I/O数据传送控制方式的比较
4.程序查询方式的特点
5.中断的概念、分类、中断优先级，开关中断和中断屏蔽
6.中断过程：中断响应和中断处理
7.中断系统的基本结构和功能
8.中断嵌套和向量中断
9.DMA方式的概念和适用范围
10.DMA方式和中断方式的比较
11.DMA方式的概念和适用范围
12.三种DMA方式的特点
13. DMA接口的结构和功能
14.通道的基本概念、用途和分类

第一章     概述

计算机是一种能对数字化信息进行自动高速运算的通用处理装置。

1．1  计算机的定义和特性 信息  运算  处理

1.1.1 什么是计算机
1.1.2 计算机的特性
计算机的特性可以归纳为高速、通用、准确、 智能四大特性。

1．2  计算机的发展历程
1.2.1 电子计算机的诞生
第一台电子计算机ENIAC（Electronic Numerical  Integrator and Computer）于1946年在美国诞生。
①每秒5000次加法运算；
②每秒50次乘法运算；
③平方和立方计算；
④Sin和Cos函数数值运算；
⑤其它更复杂的计算。 

1.2.2  第一代计算机   （20世纪40年代中到50年代末）
第一代计算机为电子管计算机，其逻辑元件采用电子 管，存储器件为声延迟线或磁鼓，典型逻辑结构为定 点运算。
计算机“软件”一词尚未出现，编制程序所用 工具为低级语言。

1.2.3  第二代计算机（50年代中后期到60年代中）
第二代计算机为晶体管计算机。这一代计算机除了逻 辑元件采用晶体管以外，其内存储器由磁芯构成，磁 鼓与磁带成为外存储器。

计算机典型逻辑结构实现了浮点运算， 并提出了变址、中断、I/O处理等新概念。
计算机软件也得到了发展，出现了多种 高级语言及其编译程序。

1.2.4 第三代计算机（60年代中到70年代中）
第三代计算机为集成电路计算机，其逻辑元件与存储器 均由集成电路实现，这是微电子与计算机技术相结合的 一大突破。
微程序控制、高速缓存、虚拟存储器、流水 线等先进计算机技术开始使用。另一大特点是大型/巨 型机与小型机同时发展。

1.2.5 第四代计算机（70年代中期开始—）
大规模（LSI）和超大规模（VLSI）集成电路 及微处理器为这一代计算机的典型特征。
并行处理技术的研究与应用以及众多巨型机的产生也成 为这一时期计算机发展的特点。
四代机时期的一个重要特点是计算机网络的发展与广泛 应用。

1.2.6 新一代计算机 新器件和非冯·诺依曼结构已成为新一代计算机的公认标志。

1．3  计算机的组成与结构

1.3.1 计算机系统的层次结构

6应用系统算法和数字模型
---------------------
5各种应用程序
---------------------
4高级程序编译,解释程序
---------------------
3操作系统
---------------------
2指令系统
---------------------
1微程序控制,PLA控制
---------------------
0逻辑硬件

1.3.2 计算机硬件
计算机硬件是指构成计算机的元器件、 部件、设备、以及它们的设计与实现技术。
冯·诺依曼计算机的主要特点： 1）计算机由运算器、存储器、控制器和输入/输出五个    部件组成。

本书讨论的范围涉及第0、1、2共3层， 主要内容如下：
1. 高速的算术、逻辑运算方法及ALU的    逻辑设计；
2. 高速的指令执行过程及指令部件的设计与实现，    是采用组合逻辑技术、或微程序设计技术，还是    PLA技术；
是复杂指令集计算机（CISC），还是    精简指令集计算机（RISC）；
3. 提高存储器容量与速度的方法，以及如何解决    “CPU-Cache-MM-外存”之间的匹配问题；
4. 高效率的输入/输出方法、组织，以及它们之间的    互联技术；
5. 计算机五大部件（运算器、控制器、存储器、输入    和输出）之间的相互作用、高效接口（总线）；

2）存储器以二进制形式存储指令和数据；
3）存储程序工作方式；
4）五部件以运算器为中心进行组织；

1.3.3 计算机软件
1. 软件的作用
一般来说，计算机的工作总是由存储程序来控制的。

软件的具体作用为：
①在计算机系统中起着指挥和管理的作用。
②是计算机用户和硬件的接口界面。
③是计算机体系结构设计的主要依据。

2. 软件的发展过程 三个阶段：
1)从第一台计算机上的第一个程序出现到 实用的高级语言出现为第一阶段（1946-1956年）。
2)从实用的高级程序设计语言出现到软件工程出现 以前为第二阶段（1956-1968年）。
3)软件工程出现以后迄今一直为第三阶段（1965—）。

3. 软件的分类
① 系统软件：操作系统、编译程序。
② 支撑软件：数据库、各类接口软件和工具组。
③ 应用软件：

1．4  计算机的分类与应用
1.4.1 计算机的分类
按计算机所处理对象的表示形式不同可以     分成模拟计算机与数字计算机两类。
计算机按其用途来分可以分成专用机和通用机两类。
其中，通用计算机按其规模、性能和价格来分，又可分为巨型机、大型机、小型机、工作站、微型机等多种类型。

1.4.2 计算机应用 计算机信息处理技术包括了对各种信息媒体的获取、 表示、加工与表现方法和技术，大致有以下几个方 面内容：
1．语言与文字的处理。
2．计算机图形学与数字图象处理。
3．多媒体技术。
4．计算机辅助技术。
5．计算机信息系统。
6．计算机控制。 计算机应用技术的发展方向为集成化、网络化、智能化

第一章 导论

第一节：数据的表示与运算。

第二节：微机的基本工作原理及结构。

第三节：微处理器概述。

第二章 8086/8088微处理器

第一节：微处理器的内部结构及引脚功能。

第二节：微机存储器组织及分段。

第三节：总线结构与总线周期。

第三章 8086/8088指令系统

第一节：八种寻址方式（立即寻址、直接寻址、寄存器寻址、寄存器间接寻址、寄存器相对寻址、基址变址寻址、基址变址且相对寻址、隐含寻址）

第二节：六类指令系统（数据传输指令、算术运算指令、逻辑运算与移位指令、串操作指令、

                     程序控制类指令、处理器控制指令）

第四章    汇编语言程序设计

第一节：汇编语言基本概念（语句结构、伪指令、运算符、宏指令、源程序结构等）

第二节：汇编语言程序设计方法（了解汇编语言程序设计的一般步骤,掌握顺序、分支、循环、

                              子程序调用等汇编语言程序设计方法。）

第五章    存储器

第一节：存储器分类及主要性能指标。

第二节：RAM、ROM简介。

第六章   输入输出与中断系统

第一节：接口概念、作用和编址方法。

第二节：输入输出传送方式（程序传送方式、中断方式、DMA方式）

第三节：8086/8088中断系统。

参考书目：

1．李伯成，侯伯亨，张毅坤.《微型计算机原理及应用》.西安：西安电子科技大学出版社. 1998年第1版.

#include <windows.h>
#include <gl/gl.h>

/**************************
 * Function Declarations
 *
 **************************/

LRESULT CALLBACK WndProc (HWND hWnd, UINT message,
WPARAM wParam, LPARAM lParam);
void EnableOpenGL (HWND hWnd, HDC *hDC, HGLRC *hRC);
void DisableOpenGL (HWND hWnd, HDC hDC, HGLRC hRC);

/**************************
 * WinMain
 *
 **************************/

int WINAPI WinMain (HINSTANCE hInstance,
                    HINSTANCE hPrevInstance,
                    LPSTR lpCmdLine,
                    int iCmdShow)
{
    WNDCLASS wc;
    HWND hWnd;
    HDC hDC;
    HGLRC hRC;       
    MSG msg;
    BOOL bQuit = FALSE;
    float theta = 0.0f;

    /* register window class */
    wc.style = CS_OWNDC;
    wc.lpfnWndProc = WndProc;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hInstance = hInstance;
    wc.hIcon = LoadIcon (NULL, IDI_APPLICATION);
    wc.hCursor = LoadCursor (NULL, IDC_ARROW);
    wc.hbrBackground = (HBRUSH) GetStockObject (BLACK_BRUSH);
    wc.lpszMenuName = NULL;
    wc.lpszClassName = "GLSample";
    RegisterClass (&wc);

    /* create main window */
    hWnd = CreateWindow (
      "GLSample", "OpenGL Sample",
      WS_CAPTION | WS_POPUPWINDOW | WS_VISIBLE,
      0, 0, 256, 256,
      NULL, NULL, hInstance, NULL);

    /* enable OpenGL for the window */
    EnableOpenGL (hWnd, &hDC, &hRC);

    /* program main loop */
    while (!bQuit)
    {
        /* check for messages */
        if (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
        {
            /* handle or dispatch messages */
            if (msg.message == WM_QUIT)
            {
                bQuit = TRUE;
            }
            else
            {
                TranslateMessage (&msg);
                DispatchMessage (&msg);
            }
        }
        else
        {
            /* OpenGL animation code goes here */

            glClearColor (0.0f, 0.0f, 0.0f, 0.0f);
            glClear (GL_COLOR_BUFFER_BIT);

            glPushMatrix ();
            glRotatef (theta, 0.0f, 0.0f, 1.0f);
            glBegin (GL_TRIANGLES);
            glColor3f (1.0f, 0.0f, 0.0f);   glVertex2f (0.0f, 1.0f);
            glColor3f (0.0f, 1.0f, 0.0f);   glVertex2f (0.87f, -0.5f);
            glColor3f (0.0f, 0.0f, 1.0f);   glVertex2f (-0.87f, -0.5f);
            glEnd ();
            glPopMatrix ();

            SwapBuffers (hDC);

            theta += 1.0f;
            Sleep (1);
        }
    }

    /* shutdown OpenGL */
    DisableOpenGL (hWnd, hDC, hRC);

    /* destroy the window explicitly */
    DestroyWindow (hWnd);

    return msg.wParam;
}

/********************
 * Window Procedure
 *
 ********************/

LRESULT CALLBACK WndProc (HWND hWnd, UINT message,
                          WPARAM wParam, LPARAM lParam)
{

    switch (message)
    {
    case WM_CREATE:
        return 0;
    case WM_CLOSE:
        PostQuitMessage (0);
        return 0;

    case WM_DESTROY:
        return 0;

    case WM_KEYDOWN:
        switch (wParam)
        {
        case VK_ESCAPE:
            PostQuitMessage(0);
            return 0;
        }
        return 0;

    default:
        return DefWindowProc (hWnd, message, wParam, lParam);
    }
}

/*******************
 * Enable OpenGL
 *
 *******************/

void EnableOpenGL (HWND hWnd, HDC *hDC, HGLRC *hRC)
{
    PIXELFORMATDESCRIPTOR pfd;
    int iFormat;

    /* get the device context (DC) */
    *hDC = GetDC (hWnd);

    /* set the pixel format for the DC */
    ZeroMemory (&pfd, sizeof (pfd));
    pfd.nSize = sizeof (pfd);
    pfd.nVersion = 1;
    pfd.dwFlags = PFD_DRAW_TO_WINDOW |
      PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
    pfd.iPixelType = PFD_TYPE_RGBA;
    pfd.cColorBits = 24;
    pfd.cDepthBits = 16;
    pfd.iLayerType = PFD_MAIN_PLANE;
    iFormat = ChoosePixelFormat (*hDC, &pfd);
    SetPixelFormat (*hDC, iFormat, &pfd);

    /* create and enable the render context (RC) */
    *hRC = wglCreateContext( *hDC );
    wglMakeCurrent( *hDC, *hRC );

}

/******************
 * Disable OpenGL
 *
 ******************/

void DisableOpenGL (HWND hWnd, HDC hDC, HGLRC hRC)
{
    wglMakeCurrent (NULL, NULL);
    wglDeleteContext (hRC);
    ReleaseDC (hWnd, hDC);
}

#define BUFSIZE 80

BOOL GetOSVer(char *szOSName);

int main()
{
 char szname[MAX_PATH];
 memset(szname,0,MAX_PATH);

 BOOL bRet = GetOSVer(szname);

 printf("Your Os version is %s\n ",szname);

 return 0;
}

BOOL GetOSVer(char *szname)
{
   OSVERSIONINFOEX osvi;
   BOOL bOsVersionInfoEx;

   // Try calling GetVersionEx using the OSVERSIONINFOEX structure.
   // If that fails, try using the OSVERSIONINFO structure.

   ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
   osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);

   if( !(bOsVersionInfoEx = GetVersionEx ((OSVERSIONINFO *) &osvi)) )
   {
      osvi.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
      if (! GetVersionEx ( (OSVERSIONINFO *) &osvi) )
         return FALSE;
   }

   switch (osvi.dwPlatformId)
   {
      // Test for the Windows NT product family.
      case VER_PLATFORM_WIN32_NT:

         // Test for the specific product family.
         if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 2 )
            strcpy(szname,"Microsoft Windows Server 2003 family, ");
  

         if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 1 )
            strcpy(szname,"Microsoft Windows XP ");

         if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 0 )
            strcpy(szname,"Microsoft Windows 2000 ");

         if ( osvi.dwMajorVersion <= 4 )
            strcpy(szname,"Microsoft Windows NT ");

         // Test for specific product on Windows NT 4.0 SP6 and later.
         if( bOsVersionInfoEx )
         {
            // Test for the workstation type.
            if ( osvi.wProductType == VER_NT_WORKSTATION )
            {
               if( osvi.dwMajorVersion == 4 )
                  strcat(szname, "Workstation 4.0 " );
               else if( osvi.wSuiteMask & VER_SUITE_PERSONAL )
                  strcat(szname, "Home Edition " );
               else
                  strcat(szname,  "Professional " );
            }
           
            // Test for the server type.
            else if ( osvi.wProductType == VER_NT_SERVER )
            {
               if( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 2 )
               {
                  if( osvi.wSuiteMask & VER_SUITE_DATACENTER )
                     strcat(szname, "Datacenter Edition " );
                  else if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE )
                     strcat(szname, "Enterprise Edition " );
                  else if ( osvi.wSuiteMask == VER_SUITE_BLADE )
                     strcat(szname, "Web Edition " );
                  else
                     strcat(szname, "Standard Edition " );
               }

               else if( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 0 )
               {
                  if( osvi.wSuiteMask & VER_SUITE_DATACENTER )
                     strcat(szname, "Datacenter Server " );
                  else if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE )
                     strcat(szname, "Advanced Server " );
                  else
                     strcat(szname, "Server " );
               }

               else  // Windows NT 4.0
               {
                  if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE )
                     strcat(szname,"Server 4.0, Enterprise Edition " );
                  else
                     strcat(szname, "Server 4.0 " );
               }
            }
         }
         else  // Test for specific product on Windows NT 4.0 SP5 and earlier
         {
            HKEY hKey;
            char szProductType[BUFSIZE];
            DWORD dwBufLen=BUFSIZE;
            LONG lRet;

            lRet = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
               "SYSTEM\\CurrentControlSet\\Control\\ProductOptions",
               0, KEY_QUERY_VALUE, &hKey );
            if( lRet != ERROR_SUCCESS )
               return FALSE;

            lRet = RegQueryValueEx( hKey, "ProductType", NULL, NULL,
               (LPBYTE) szProductType, &dwBufLen);
            if( (lRet != ERROR_SUCCESS) || (dwBufLen > BUFSIZE) )
               return FALSE;

            RegCloseKey( hKey );

            if ( lstrcmpi( "WINNT", szProductType) == 0 )
               strcat(szname, "Workstation " );
            if ( lstrcmpi( "LANMANNT", szProductType) == 0 )
               strcat(szname, "Server " );
            if ( lstrcmpi( "SERVERNT", szProductType) == 0 )
               strcat(szname,"Advanced Server " );

            printf( "%d.%d ", osvi.dwMajorVersion, osvi.dwMinorVersion );
         }

      // Display service pack (if any) and build number.

         if( osvi.dwMajorVersion == 4 &&
             lstrcmpi( osvi.szCSDVersion, "Service Pack 6" ) == 0 )
         {
            HKEY hKey;
            LONG lRet;

            // Test for SP6 versus SP6a.
            lRet = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
               "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Hotfix\\Q246009",
               0, KEY_QUERY_VALUE, &hKey );
            if( lRet == ERROR_SUCCESS )
               printf( "Service Pack 6a (Build %d)\n", osvi.dwBuildNumber & 0xFFFF );        
            else // Windows NT 4.0 prior to SP6a
            {
               printf( "%s (Build %d)\n",
                  osvi.szCSDVersion,
                  osvi.dwBuildNumber & 0xFFFF);
            }

            RegCloseKey( hKey );
         }
         else // Windows NT 3.51 and earlier or Windows 2000 and later
         {
            printf( "%s (Build %d)\n",
               osvi.szCSDVersion,
               osvi.dwBuildNumber & 0xFFFF);
         }

         break;

      // Test for the Windows 95 product family.
      case VER_PLATFORM_WIN32_WINDOWS:

         if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 0)
         {
             strcpy(szname,"Microsoft Windows 95 ");
             if ( osvi.szCSDVersion[1] == 'C' || osvi.szCSDVersion[1] == 'B' )
                strcat(szname,"OSR2 " );
         }

         if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 10)
         {
             strcpy(szname,"Microsoft Windows 98 ");
             if ( osvi.szCSDVersion[1] == 'A' )
                strcat(szname,"SE " );
         }

         if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 90)
         {
             strcpy(szname,"Microsoft Windows Millennium Edition\n");
         }
         break;

      case VER_PLATFORM_WIN32s:

         printf ("Microsoft Win32s\n");
         break;
   }
  // getchar();
   return TRUE;
}

灵活运用C编译器.目前Linux下最常用的C语言编译器是GCC(GNU Compiler Collection),它是GNU项目中符合ANSI C

标准的编译系统,能够编译用C、C++和Object C等语言编写的程序.GCC不仅功能非常强大,结构也异常灵活.最值得称

道的一点就是它可以通过不同的前端模块来支持各种语言,如Java、Fortran、Pascal、Modula-3和Ada等.

开放、自由和灵活是Linux的魅力所在,而这一点在GCC上的体现就是程序员通过它能够更好地控制整个编译过程.在

使用GCC编译程序时,编译过程可以被细分为四个阶段:

◆ 预处理(Pre-Processing)

◆ 编译(Compiling)

◆ 汇编(Assembling)

◆ 链接(Linking)

Linux程序员可以根据自己的需要让GCC在编译的任何阶段结束,以便检查或使用编译器在该阶段的输出信息,或者对

最后生成的二进制文件进行控制,以便通过加入不同数量和种类的调试代码来为今后的调试做好准备.和其它常用的

编译器一样,GCC也提供了灵活而强大的代码优化功能,利用它可以生成执行效率更高的代码.

GCC提供了30多条警告信息和三个警告级别,使用它们有助于增强程序的稳定性和可移植性.此外,GCC还对标准的C和

C++语言进行了大量的扩展,提高程序的执行效率,有助于编译器进行代码优化,能够减轻编程的工作量.

GCC起步

在学习使用GCC之前,下面的这个例子能够帮助用户迅速理解GCC的工作原理,并将其立即运用到实际的项目开发中去.

首先用熟悉的编辑器输入清单1所示的代码:

清单1:hello.c

#include <stdio.h>
int main(void)
{
 printf (Hello world, Linux programming!\\n);
 return 0;
}
 

然后执行下面的命令编译和运行这段程序:

# gcc hello.c -o hello
# ./hello
Hello world, Linux programming!
 

从程序员的角度看,只需简单地执行一条GCC命令就可以了,但从编译器的角度来看,却需要完成一系列非常繁杂的工

作.首先,GCC需要调用预处理程序cpp,由它负责展开在源文件中定义的宏,并向其中插入“#include”语句所包含的

内容；接着,GCC会调用ccl和as将处理后的源代码编译成目标代码；最后,GCC会调用链接程序ld,把生成的目标代码

链接成一个可执行程序.

为了更好地理解GCC的工作过程,可以把上述编译过程分成几个步骤单独进行,并观察每步的运行结果.第一步是进行

预编译,使用-E参数可以让GCC在预处理结束后停止编译过程:

#  gcc -E hello.c -o hello.i
 

此时若查看hello.cpp文件中的内容,会发现stdio.h的内容确实都插到文件里去了,而其它应当被预处理的宏定义也

都做了相应的处理.下一步是将hello.i编译为目标代码,这可以通过使用-c参数来完成:

#  gcc -c hello.i -o hello.o
 

GCC默认将.i文件看成是预处理后的C语言源代码,因此上述命令将自动跳过预处理步骤而开始执行编译过程,也可以

使用-x参数让GCC从指定的步骤开始编译.最后一步是将生成的目标文件链接成可执行文件:

#  gcc hello.o -o hello
 

在采用模块化的设计思想进行软件开发时,通常整个程序是由多个源文件组成的,相应地也就形成了多个编译单元,使

用GCC能够很好地管理这些编译单元.假设有一个由foo1.c和foo2.c两个源文件组成的程序,为了对它们进行编译,并

最终生成可执行程序foo,可以使用下面这条命令:

#  gcc foo1.c foo2.c -o foo
 

如果同时处理的文件不止一个,GCC仍然会按照预处理、编译和链接的过程依次进行.如果深究起来,上面这条命令大

致相当于依次执行如下三条命令:

# gcc -c foo1.c -o foo1.o
# gcc -c foo2.c -o foo2.o
# gcc foo1.o foo2.o -o foo
 

在编译一个包含许多源文件的工程时,若只用一条GCC命令来完成编译是非常浪费时间的.假设项目中有100个源文件

需要编译,并且每个源文件中都包含10000行代码,如果像上面那样仅用一条GCC命令来完成编译工作,那么GCC需要将

每个源文件都重新编译一遍,然后再全部连接起来.很显然,这样浪费的时间相当多,尤其是当用户只是修改了其中某

一个文件的时候,完全没有必要将每个文件都重新编译一遍,因为很多已经生成的目标文件是不会改变的.要解决这个

问题,关键是要灵活运用GCC,同时还要借助像Make这样的工具.

警告提示功能

GCC包含完整的出错检查和警告提示功能,它们可以帮助Linux程序员写出更加专业和优美的代码.先来读读清单2所示

的程序,这段代码写得很糟糕,仔细检查一下不难挑出很多毛病:

◆main函数的返回值被声明为void,但实际上应该是int；

◆使用了GNU语法扩展,即使用long long来声明64位整数,不符合ANSI/ISO C语言标准；

◆main函数在终止前没有调用return语句.

清单2:illcode.c

#include <stdio.h>
void main(void)
{
  long long int var = 1;
  printf(It is not standard C code!\\n);
}
 

下面来看看GCC是如何帮助程序员来发现这些错误的.当GCC在编译不符合ANSI/ISO C语言标准的源代码时,如果加上

了-pedantic选项,那么使用了扩展语法的地方将产生相应的警告信息:

# gcc -pedantic illcode.c -o illcode
illcode.c: In function `main':
illcode.c:9: ISO C89 does not support `long long'
illcode.c:8: return type of `main' is not `int'
 

需要注意的是,-pedantic编译选项并不能保证被编译程序与ANSI/ISO C标准的完全兼容,它仅仅只能用来帮助Linux

程序员离这个目标越来越近.或者换句话说,-pedantic选项能够帮助程序员发现一些不符合ANSI/ISO C标准的代码,

但不是全部,事实上只有ANSI/ISO C语言标准中要求进行编译器诊断的那些情况,才有可能被GCC发现并提出警告.

除了-pedantic之外,GCC还有一些其它编译选项也能够产生有用的警告信息.这些选项大多以-W开头,其中最有价值的

当数-Wall了,使用它能够使GCC产生尽可能多的警告信息:

# gcc -Wall illcode.c -o illcode
illcode.c:8: warning: return type of `main' is not `int'
illcode.c: In function `main':
illcode.c:9: warning: unused variable `var'
 

GCC给出的警告信息虽然从严格意义上说不能算作是错误,但却很可能成为错误的栖身之所.一个优秀的Linux程序员

应该尽量避免产生警告信息,使自己的代码始终保持简洁、优美和健壮的特性.

在处理警告方面,另一个常用的编译选项是-Werror,它要求GCC将所有的警告当成错误进行处理,这在使用自动编译工

具(如Make等)时非常有用.如果编译时带上-Werror选项,那么GCC会在所有产生警告的地方停止编译,迫使程序员对自

己的代码进行修改.只有当相应的警告信息消除时,才可能将编译过程继续朝前推进.执行情况如下:

# gcc -Wall -Werror illcode.c -o illcode
cc1: warnings being treated as errors
illcode.c:8: warning: return type of `main' is not `int'
illcode.c: In function `main':
illcode.c:9: warning: unused variable `var'
 

对Linux程序员来讲,GCC给出的警告信息是很有价值的,它们不仅可以帮助程序员写出更加健壮的程序,而且还是跟踪

和调试程序的有力工具.建议在用GCC编译源代码时始终带上-Wall选项,并把它逐渐培养成为一种习惯,这对找出常见

的隐式编程错误很有帮助.

库依赖

在Linux下开发软件时,完全不使用第三方函数库的情况是比较少见的,通常来讲都需要借助一个或多个函数库的支持

才能够完成相应的功能.从程序员的角度看,函数库实际上就是一些头文件(.h)和库文件(.so或者.a)的集合.虽然

Linux下的大多数函数都默认将头文件放到/usr/include/目录下,而库文件则放到/usr/lib/目录下,但并不是所有的

情况都是这样.正因如此,GCC在编译时必须有自己的办法来查找所需要的头文件和库文件.

GCC采用搜索目录的办法来查找所需要的文件,-I选项可以向GCC的头文件搜索路径中添加新的目录.例如,如果

在/home/xiaowp/include/目录下有编译时所需要的头文件,为了让GCC能够顺利地找到它们,就可以使用-I选项:

# gcc foo.c -I /home/xiaowp/include -o foo
 

同样,如果使用了不在标准位置的库文件,那么可以通过-L选项向GCC的库文件搜索路径中添加新的目录.例如,如果在

/home/xiaowp/lib/目录下有链接时所需要的库文件libfoo.so,为了让GCC能够顺利地找到它,可以使用下面的命令:

# gcc foo.c -L /home/xiaowp/lib -lfoo -o foo
 

值得好好解释一下的是-l选项,它指示GCC去连接库文件libfoo.so.Linux下的库文件在命名时有一个约定,那就是应

该以lib三个字母开头,由于所有的库文件都遵循了同样的规范,因此在用-l选项指定链接的库文件名时可以省去lib

三个字母,也就是说GCC在对-lfoo进行处理时,会自动去链接名为libfoo.so的文件.

Linux下的库文件分为两大类分别是动态链接库(通常以.so结尾)和静态链接库(通常以.a结尾),两者的差别仅在程序

执行时所需的代码是在运行时动态加载的,还是在编译时静态加载的.默认情况下,GCC在链接时优先使用动态链接库,

只有当动态链接库不存在时才考虑使用静态链接库,如果需要的话可以在编译时加上-static选项,强制使用静态链接

库.例如,如果在/home/xiaowp/lib/目录下有链接时所需要的库文件libfoo.so和libfoo.a,为了让GCC在链接时只用

到静态链接库,可以使用下面的命令:

# gcc foo.c -L /home/xiaowp/lib -static -lfoo -o foo
 
代码优化

代码优化指的是编译器通过分析源代码,找出其中尚未达到最优的部分,然后对其重新进行组合,目的是改善程序的执

行性能.GCC提供的代码优化功能非常强大,它通过编译选项-On来控制优化代码的生成,其中n是一个代表优化级别的

整数.对于不同版本的GCC来讲,n的取值范围及其对应的优化效果可能并不完全相同,比较典型的范围是从0变化到2或

3.

编译时使用选项-O可以告诉GCC同时减小代码的长度和执行时间,其效果等价于-O1.在这一级别上能够进行的优化类

型虽然取决于目标处理器,但一般都会包括线程跳转(Thread Jump)和延迟退栈(Deferred Stack Pops)两种优化.选

项-O2告诉GCC除了完成所有-O1级别的优化之外,同时还要进行一些额外的调整工作,如处理器指令调度等.选项-O3则

除了完成所有-O2级别的优化之外,还包括循环展开和其它一些与处理器特性相关的优化工作.通常来说,数字越大优

化的等级越高,同时也就意味着程序的运行速度越快.许多Linux程序员都喜欢使用-O2选项,因为它在优化长度、编译

时间和代码大小之间,取得了一个比较理想的平衡点.

下面通过具体实例来感受一下GCC的代码优化功能,所用程序如清单3所示.

清单3:optimize.c

#include <stdio.h>
int main(void)
{
  double counter;
  double result;
  double temp;
  for (counter = 0;
   counter < 2000.0 * 2000.0 * 2000.0  / 20.0 + 2020;
   counter += (5 - 1) / 4) {
    temp = counter / 1979;
    result  = counter;   
  }
  printf(Result is %lf\\n, result);
  return 0;
}
 

首先不加任何优化选项进行编译:

# gcc -Wall optimize.c -o optimize
 

借助Linux提供的time命令,可以大致统计出该程序在运行时所需要的时间:

# time ./optimize
Result is 400002019.000000
real    0m14.942s
user    0m14.940s
sys     0m0.000s
 

接下去使用优化选项来对代码进行优化处理:

# gcc -Wall -O optimize.c -o optimize
 

在同样的条件下再次测试一下运行时间:

# time ./optimize
Result is 400002019.000000
real    0m3.256s
user    0m3.240s
sys     0m0.000s
 

对比两次执行的输出结果不难看出,程序的性能的确得到了很大幅度的改善,由原来的14秒缩短到了3秒.这个例子是

专门针对GCC的优化功能而设计的,因此优化前后程序的执行速度发生了很大的改变.尽管GCC的代码优化功能非常强

大,但作为一名优秀的Linux程序员,首先还是要力求能够手工编写出高质量的代码.如果编写的代码简短,并且逻辑性

强,编译器就不会做更多的工作,甚至根本用不着优化.

优化虽然能够给程序带来更好的执行性能,但在如下一些场合中应该避免优化代码:

◆ 程序开发的时候 优化等级越高,消耗在编译上的时间就越长,因此在开发的时候最好不要使用优化选项,只有到软

件发行或开发结束的时候,才考虑对最终生成的代码进行优化.

◆ 资源受限的时候 一些优化选项会增加可执行代码的体积,如果程序在运行时能够申请到的内存资源非常紧张(如

一些实时嵌入式设备),那就不要对代码进行优化,因为由这带来的负面影响可能会产生非常严重的后果.

◆ 跟踪调试的时候 在对代码进行优化的时候,某些代码可能会被删除或改写,或者为了取得更佳的性能而进行重组,

从而使跟踪和调试变得异常困难.

调试

一个功能强大的调试器不仅为程序员提供了跟踪程序执行的手段,而且还可以帮助程序员找到解决问题的方法.对于

Linux程序员来讲,GDB(GNU Debugger)通过与GCC的配合使用,为基于Linux的软件开发提供了一个完善的调试环境.

默认情况下,GCC在编译时不会将调试符号插入到生成的二进制代码中,因为这样会增加可执行文件的大小.如果需要

在编译时生成调试符号信息,可以使用GCC的-g或者-ggdb选项.GCC在产生调试符号时,同样采用了分级的思路,开发人

员可以通过在-g选项后附加数字1、2或3来指定在代码中加入调试信息的多少.默认的级别是2(-g2),此时产生的调试

信息包括扩展的符号表、行号、局部或外部变量信息.级别3(-g3)包含级别2中的所有调试信息,以及源代码中定义的

宏.级别1(-g1)不包含局部变量和与行号有关的调试信息,因此只能够用于回溯跟踪和堆栈转储之用.回溯跟踪指的是

监视程序在运行过程中的函数调用历史,堆栈转储则是一种以原始的十六进制格式保存程序执行环境的方法,两者都

是经常用到的调试手段.

GCC产生的调试符号具有普遍的适应性,可以被许多调试器加以利用,但如果使用的是GDB,那么还可以通过-ggdb选项

在生成的二进制代码中包含GDB专用的调试信息.这种做法的优点是可以方便GDB的调试工作,但缺点是可能导致其它

调试器(如DBX)无法进行正常的调试.选项-ggdb能够接受的调试级别和-g是完全一样的,它们对输出的调试符号有着

相同的影响.

需要注意的是,使用任何一个调试选项都会使最终生成的二进制文件的大小急剧增加,同时增加程序在执行时的开销,

因此调试选项通常仅在软件的开发和调试阶段使用.调试选项对生成代码大小的影响从下面的对比过程中可以看出来

:

# gcc optimize.c -o optimize
# ls optimize -l
-rwxrwxr-x  1 xiaowp   xiaowp  11649 Nov 20 08:53 optimize  (未加调试选项)
# gcc -g optimize.c -o optimize
# ls optimize -l
-rwxrwxr-x  1 xiaowp   xiaowp  15889 Nov 20 08:54 optimize  (加入调试选项)
 

虽然调试选项会增加文件的大小,但事实上Linux中的许多软件在测试版本甚至最终发行版本中仍然使用了调试选项

来进行编译,这样做的目的是鼓励用户在发现问题时自己动手解决,是Linux的一个显著特色.

为调试编译代码(Compiling Code for Debugging)
为了使 gdb 正常工作, 你必须使你的程序在编译时包含调试信息. 调试信息包含你程序里的每个变量的类型和在可

执行文件里的地址映射以及源代码的行号. gdb 利用这些信息使源代码和机器码相关联.
◆在编译时用 -g 选项打开调试选项.
 

gdb 基本命令
     gdb 支持很多的命令使你能实现不同的功能. 这些命令从简单的文件装入到允许你检查所调用的堆栈内容的复

杂命令, 表27.1列出了你在用 gdb 调试时会用到的一些命令. 想了解 gdb 的详细使用请参考 gdb 的指南页.
  表 27.1. 基本 gdb 命令.
命   令 描  述
file 装入想要调试的可执行文件.
kill 终止正在调试的程序.
list 列出产生执行文件的源代码的一部分.
next 执行一行源代码但不进入函数内部.
step 执行一行源代码而且进入函数内部.
run 执行当前被调试的程序
quit 终止 gdb
watch 使你能监视一个变量的值而不管它何时被改变.
break 在代码里设置断点, 这将使程序执行到这里时被挂起.
make 使你能不退出 gdb 就可以重新产生可执行文件.
shell 使你能不离开 gdb 就执行 UNIX shell 命令. 

gdb 支持很多与 UNIX shell 程序一样的命令编辑特征. 你能象在 bash 或 tcsh里那样按 Tab 键让gdb 帮你补齐

一个唯一的命令, 如果不唯一的话 gdb 会列出所有匹配的命令. 你也能用光标键上下翻动历史命令.

下面还是通过一个具体的实例说明如何利用调试符号来分析错误,所用程序见清单4所示.

清单4:crash.c

#include <stdio.h>
int main(void)
{
  int input =0;
  printf(Input an integer:);
  scanf(%d, input);
  printf(The integer you input is %d\\n, input);
  return 0;
}
 

编译并运行上述代码,会产生一个严重的段错误(Segmentation fault)如下:

# gcc -g crash.c -o crash
# ./crash
Input an integer:10
Segmentation fault
 

为了更快速地发现错误所在,可以使用GDB进行跟踪调试,方法如下:

# gdb crash
GNU gdb Red Hat Linux (5.3post-0.20021129.18rh)
……
(gdb)
 

当GDB提示符出现的时候,表明GDB已经做好准备进行调试了,现在可以通过run命令让程序开始在GDB的监控下运行:

(gdb) run
Starting program: /home/xiaowp/thesis/gcc/code/crash
Input an integer:10

Program received signal SIGSEGV, Segmentation fault.
0x4008576b in _IO_vfscanf_internal () from /lib/libc.so.6
 

仔细分析一下GDB给出的输出结果不难看出,程序是由于段错误而导致异常中止的,说明内存操作出了问题,具体发生

问题的地方是在调用_IO_vfscanf_internal ( )的时候.为了得到更加有价值的信息,可以使用GDB提供的回溯跟踪命

令backtrace,执行结果如下:

(gdb) backtrace
#0  0x4008576b in _IO_vfscanf_internal () from /lib/libc.so.6
#1  0xbffff0c0 in ?? ()
#2  0x4008e0ba in scanf () from /lib/libc.so.6
#3  0x08048393 in main () at crash.c:11
#4  0x40042917 in __libc_start_main () from /lib/libc.so.6
 

跳过输出结果中的前面三行,从输出结果的第四行中不难看出,GDB已经将错误定位到crash.c中的第11行了.现在仔细

检查一下:

(gdb) frame 3
#3  0x08048393 in main () at crash.c:11
11       scanf(%d, input);
 

使用GDB提供的frame命令可以定位到发生错误的代码段,该命令后面跟着的数值可以在backtrace命令输出结果中的

行首找到.现在已经发现错误所在了,应该将

scanf(%d, input);
改为
scanf(%d, &input);
 

完成后就可以退出GDB了,命令如下:

(gdb) quit
 

GDB的功能远远不止如此,它还可以单步跟踪程序、检查内存变量和设置断点等.

调试时可能会需要用到编译器产生的中间结果,这时可以使用-save-temps选项,让GCC将预处理代码、汇编代码和目

标代码都作为文件保存起来.如果想检查生成的代码是否能够通过手工调整的办法来提高执行性能,在编译过程中生

成的中间文件将会很有帮助,具体情况如下:

# gcc -save-temps foo.c -o foo
# ls foo*
foo  foo.c  foo.i  foo.s
 

GCC支持的其它调试选项还包括-p和-pg,它们会将剖析(Profiling)信息加入到最终生成的二进制代码中.剖析信息对

于找出程序的性能瓶颈很有帮助,是协助Linux程序员开发出高性能程序的有力工具.在编译时加入-p选项会在生成的

代码中加入通用剖析工具(Prof)能够识别的统计信息,而-pg选项则生成只有GNU剖析工具(Gprof)才能识别的统计信

息.

最后提醒一点,虽然GCC允许在优化的同时加入调试符号信息,但优化后的代码对于调试本身而言将是一个很大的挑战

.代码在经过优化之后,在源程序中声明和使用的变量很可能不再使用,控制流也可能会突然跳转到意外的地方,循环

语句有可能因为循环展开而变得到处都有,所有这些对调试来讲都将是一场噩梦.建议在调试的时候最好不使用任何

优化选项,只有当程序在最终发行的时候才考虑对其进行优化.

上次的培训园地中介绍了GCC的编译过程、警告提示功能、库依赖、代码优化和程序调试六个方面的内容.这期是最

后的一部分内容.

加速

在将源代码变成可执行文件的过程中,需要经过许多中间步骤,包含预处理、编译、汇编和连接.这些过程实际上是由

不同的程序负责完成的.大多数情况下GCC可以为Linux程序员完成所有的后台工作,自动调用相应程序进行处理.

这样做有一个很明显的缺点,就是GCC在处理每一个源文件时,最终都需要生成好几个临时文件才能完成相应的工作,

从而无形中导致处理速度变慢.例如,GCC在处理一个源文件时,可能需要一个临时文件来保存预处理的输出、一个临

时文件来保存编译器的输出、一个临时文件来保存汇编器的输出,而读写这些临时文件显然需要耗费一定的时间.当

软件项目变得非常庞大的时候,花费在这上面的代价可能会变得很沉重.

解决的办法是,使用Linux提供的一种更加高效的通信方式—管道.它可以用来同时连接两个程序,其中一个程序的输

出将被直接作为另一个程序的输入,这样就可以避免使用临时文件,但编译时却需要消耗更多的内存.

在编译过程中使用管道是由GCC的-pipe选项决定的.下面的这条命令就是借助GCC的管道功能来提高编译速度的:

# gcc -pipe foo.c -o foo
 

在编译小型工程时使用管道,编译时间上的差异可能还不是很明显,但在源代码非常多的大型工程中,差异将变得非常

明显.

文件扩展名

在使用GCC的过程中,用户对一些常用的扩展名一定要熟悉,并知道其含义.为了方便大家学习使用GCC,在此将这些扩

展名罗列如下:

.c C原始程序；

.C C++原始程序；

.cc C++原始程序；

.cxx C++原始程序；

.m Objective-C原始程序；

.i 已经过预处理的C原始程序；

.ii 已经过预处理之C++原始程序；

.s 组合语言原始程序；

.S 组合语言原始程序；

.h 预处理文件(标头文件)；

.o 目标文件；

.a 存档文件.

GCC常用选项

GCC作为Linux下C/C++重要的编译环境,功能强大,编译选项繁多.为了方便大家日后编译方便,在此将常用的选项及说

明罗列出来如下:

-c 通知GCC取消链接步骤,即编译源码并在最后生成目标文件；

-Dmacro 定义指定的宏,使它能够通过源码中的#ifdef进行检验；

-E 不经过编译预处理程序的输出而输送至标准输出；

-g3 获得有关调试程序的详细信息,它不能与-o选项联合使用；

-Idirectory 在包含文件搜索路径的起点处添加指定目录；

-llibrary 提示链接程序在创建最终可执行文件时包含指定的库；

-O、-O2、-O3 将优化状态打开,该选项不能与-g选项联合使用；

-S 要求编译程序生成来自源代码的汇编程序输出；

-v 启动所有警报；

-Wall 在发生警报时取消编译操作,即将警报看作是错误；

-Werror 在发生警报时取消编译操作,即把报警当作是错误；

-w 禁止所有的报警.

小结

GCC是在Linux下开发程序时必须掌握的工具之一.本文对GCC做了一个简要的介绍,主要讲述了如何使用GCC编译程序

、产生警告信息、调试程序和加快GCC的编译速度.对所有希望早日跨入Linux开发者行列的人来说,GCC就是成为一名

优秀的Linux程序员的起跑线.

http://delia.org.ru/ArticleView/2005-9-7/Article_View_131482.Htm