qt条件编译

Ⅰ 宏名是什么

问题一：EXCEL 宏的名称怎么设置？ 按钮的本质就是一个宏，所以在制作按钮之前，我们先来录制一个宏，把宏都准备好了，就可以制作按钮了。先打开一个表格如图所示，选中大标题，接下来我们在菜单栏上执行：开发工具－－宏
设置宏名称为【大标题】，保存位置为【个人宏工作簿】，这样打开任意的excel就能看到这个宏，如果保存在【当前工作簿】就只能在这个excel文件中看到该宏了。
右键单击已经选中的单元格，在打开的右键菜单中，选择【设置单元格格式】
在打开的单元格格式对话框中，切换到对齐选项下，然后设置水平对齐、垂直对齐、合并单元格。
切换到字体选项下，然后设置字形和字号，最后点击确定按钮。字形和字号的设置要符合大标题醒目的要求。
设置好了大标题的格式以后，我们就点击开发工具下的【停止录制】
接下来再录制一个宏，这回是设置小标题的格式，设置流畅图我已经贴在下面了，由于和上面的步骤一样，这里就不讲解了。
录制好宏以后，我们在菜单栏上执行：开发工具－－插入，在打开的列表中选择按钮。
拖动鼠标就可以绘制出一个按钮，同时会打开一个指定宏的对话框，选择【大标题】这个宏，然后点击确定按钮。
将按钮上的文字设置成为：设置大标题格式。如果你对按钮上的文字要求更高，要设置他的字体和大小，还可以右键单击按钮，选择设置空间格式，对文字进行更具体的设置。
同样的方法我们再添加一个按钮2，指定的宏为小标题。
最后我们换一种方式来插入按钮，前面所讲的按钮都是先建立宏，然后再添加按钮，现在先插入一个按钮，再建立宏，如图所示，先选中一个要设定格式的单元格，然后再菜单栏上执行开发工具－－插入，插入一个按钮。
拖动鼠标绘制一个按钮，然后就自动打开这个对话框，设置宏名为【设置列标题】，然后点击右侧的【录制】
打开录制宏对话框，设置宏名，然后点击确定。下面就开始对单元格的格式进行设置，所有的设置都会记录在宏里。
单元格设置完成了以后，再执行：开发工具－－停止录制
将该按钮的文字设置为：设置列标题格式，这样就完成了按钮的制作。

问题二：宏名是什么c语言宏是什么意思 有的时候为了程序的通用性，可以使用＃define预处理宏定义命令，它的具体作用，就是方便程序段的定义和修改。
举个例子吧，如果说你在做一个项目，这个项目的代码很长，有5000多行，而且基本上Y面的同一个常量N就占了3000多行，如果说今后你要是想对这个常量N的值进行修改，如果在程序的开始没有定义一个＃define N，那么改起来不是很麻烦，3000多行啊，那不是要晕过去了～如果你事先定义了一个＃define N ‘常量值’，那么当你要修改程序内部的常量值时，只要修改N后面的常量值就等于把程序内部的要修改的相同常量值都改了，那就很方便了

问题三：c语言中宏名是什么类型? 楼上的基本对。不过：
不是什么都有类型的，宏根本不是C编译器看得到的东西。
类型是编译器决定的，类型是编译器对变量、函数等分析的结果。
你说关键字“sizeof”是什么类型？
那些东西不是变量、也不是常量、不能引用、哪里有类型？
一般的，有类型的东西至少要是一个表示时间含义的常量、变量、函数等。
------------------------------------------------------------
#define MAX 10
int a = MAX;这里就MAX替换为10，这时10为整形
char s = MAX;这里就MAX替换为10，这时10自动转为字符型
在这里：10在任何时候都是整型，因为词法分析的时候，常量的类型就已经确定。
char s= int (10)，但是s是char型，会自动转换。
C语言里表现不明显，毕竟是一个弱类型语言。
C++里面重载后，你看看会调用那个函数！

问题四：取名带宏是什么意思 主要字义：宏字的主要含义是表示广大和广博。用在人名中主要有宏材大略、宏伟、博大、功德广博等义。“宏”字是一个水木五行皆有的姓名用字。

问题五：类声明时，类名前面加宏名是什么意思 类声明时，类名前面加宏名是什么意思
#if !defined(QWEBKIT_EXPORT) 如果没定义QWEBKIT_EXPORT
# if defined(QT_SHARED) 如果定义了QT_SHARED
# define Q_DECL_EXPORT Q_DECL_EXPORT 将Q_DECL_EXPORT 定义成 Q_DECL_EXPORT
# else
# define QWEBKIT_EXPORT 将QWEBKIT_EXPORT 定义为空
# endif
#endif
而Q_DECL_EXPORT 也是一个宏，它结果有几个，如__declspec(dllexport)
__attribute__((visibility(default))) 等

问题六：Excel 宏的名称定义有什么要求 不能是数字开头，不能有特殊符号。

问题七：真宏名字是什么意思 ？？？？？？？

问题八：取名字宏字后面加什么字好听 宏斌
宏磊
宏陶
最好说下姓什么？得搭配姓氏才知道加什么好听

问题九：c语言中的“宏”是指什么？ 简单来说：宏定义又称为宏代换、宏替换，简称“宏”。是C提供的三种预处理功能的其中一种。
复杂的请看下面，讲的很全。下面的带参宏定义，多行宏定义，在linux内核源码中很多。另外sizeof也是一个宏定义。
宏定义
宏定义是C提供的三种预处理功能的其中一种，这三种预处理包括：宏定义、文件包含、条件编译
1. 不带参数的宏定义：
宏定义又称为宏代换、宏替换，简称“宏”。
格式： #define 标识符 字符串
其中的标识符就是所谓的符号常量，也称为“宏名”。
预处理（预编译）工作也叫做宏展开：将宏名替换为字符串。
掌握宏概念的关键是“换”。一切以换为前提、做任何事情之前先要换，准确理解之前就要“换”。
即在对相关命令或语句的含义和功能作具体分析之前就要换：
例： #define PI 3.1415926 把程序中出现的PI全部换成3.1415926
说明：
（1）宏名一般用大写
（2）使用宏可提高程序的通用性和易读性，减少不一致性，减少输入错误和便于修改。例如：数组大小常用宏定义
（3）预处理是在编译之前的处理，而编译工作的任务之一就是语法检查，预处理不做语法检查。
（4）宏定义末尾不加分号；
（5）宏定义写在函数的花括号外边，作用域为其后的程序，通常在文件的最开头。
（6）可以用#undef命令终止宏定义的作用域
（7）宏定义可以嵌套
（8）字符串 中永远不包含宏
（9）宏定义不分配内存，变量定义分配内存。
2. 带参数的宏定义：
除了一般的字符串替换，还要做参数代换
格式： #define 宏名（参数表） 字符串
例如：#define S（a,b） a*b
area=S（3,2）；第一步被换为area=a*b; ，第二步被换为area=3*2;
类似于函数调用，有一个哑实结合的过程：
（1）实参如果是表达式容易出问题
#define S（r） r*r
area=S（a+b）；第一步换为area=r*r;,第二步被换为area=a+b*a+b;
正确的宏定义是#define S（r） （（r）*（r））
（2）宏名和参数的括号间不能有空格
（3）宏替换只作替换，不做计算，不做表达式求解
（4）函数调用在编译后程序运行时进行，并且分配内存。宏替换在编译前进行，不分配内存
（5）宏的哑实结合不存在类型，也没有类型转换。
（6）函数只有一个返回值，利用宏则可以设法得到多个值
（7）宏展开使源程序变长，函数调用不会
（8）宏展开不占运行时间，只占编译时间，函数调用占运行时间（分配内存、保留现场、值传递、返回值）
3. 宏定义其他冷门、重点知识
#define用法
1、 用无参宏定义一个简单的常量
#define LEN 12
这个是最常见的用法，但也会出错。
比如下面几个知识点你会吗？可以看下：
（1） #define NAME zhangyuncong
程序中有NAME则，它会不会被替换呢？
......>>

问题十：宏字头取什么名字 宏伟公司，这个名字我觉得特别特别特别特别特别特别的好，我觉得取这个名字以后，公司是你们公司的发展也会越来越好。

Ⅱ 我在windows下用QT写了个程序，把这个源代码直接在linux下编译可以吗

可以，只要你不调用Windows的API函数就可以。 还有你在不同的系统可以使用条件编译那样就不存在任何问题了

Ⅲ #error "This file was generated using the moc from 4.6.2. It"

#error
人为的产生一个error并中断编译
一般用作环境判断 放在条件编译中
当若干条件被满足或者不满足时 停止程序编译 并打印错误输出

类似的还有#warning 产生一个警告信息 但不中断编译
对于#error/#waring的输出 不同编译器有不同做法 有的输出其后的字符串 有的输出所有(包括#xxx)
对于你这个代码 如果Q_MOC_OUTPUT_REVISION没有被定义
那么编译的时候会输出类似
<filename> <line number> <col_number> error: #error "The header file 'processimage.h' doesn't include <QObject>."
错误
如果Q_MOC_OUTPUT_REVISION 值不是59 会输出
<filename> <line number> <col_number> error: #error "This file was generated using the moc from 4.6.2. It"
<filename> <line number> <col_number> error: #error "cannot be used with the include files from this version of Qt."
<filename> <line number> <col_number> #error "(The moc has changed too much.)"

是否有问题？ 有问题请追问 没问题请采纳

Ⅳ 如何在QT中读取串口数据

一、文件下载

文件下载地址：

也可以下载我上传到网盘上的：

二、文件内容介绍

1.下载到的文件为qextserialport-1.2win-alpha ，解压并打开后其内容如下。

（点击图片可以查看清晰大图）

下面分别介绍：

（1）doc文件夹中的文件内容是QextSerialPort类和QextBaseType的简单的说明，我们可以使用记事本程序将它们打开。

（2）examples文件夹中是几个例子程序，可以看一下它的源码，不过想运行它们好像会出很多问题啊。

（3）html文件夹中是QextSerialPort类的使用文档。

（4）然后就是剩下的几个文件了。其中qextserialenumerator.cpp及qextserialenumerator.h文件中定
义的QextSerialEnumerator类是用来获取平台上可用的串口信息的。不过，这个类好像并不怎么好用，而且它不是我们关注的重点，所以下面
就不再介绍它了。

（5）qextserialbase.cpp和qextserialbase.h文件定义了一个QextSerialBase
类，win_qextserialport.cpp和win_qextserialport.h文件定义了一个Win_QextSerialPort
类，posix_qextserialport.cpp和posix_qextserialport.h文件定义了一个
Posix_QextSerialPort类，qextserialport.cpp和qextserialport.h文件定义了一个
QextSerialPort类。这个QextSerialPort类就是我们上面所说的那个，它是所有这些类的子类，是最高的抽象，它屏蔽了平台特征，
使得在任何平台上都可以使用它。

2.几个类的简单介绍。

下面是这几个类的关系图。

可以看到它们都继承自QIODevice类，所以该类的一些函数我们也可以直接来使用。图中还有一个QextBaseType类，其实它只是一个标
识，没有具体的内容，它用来表示Win_QextSerialPort或Posix_QextSerialPort
中的一个类，因为在QextSerialPort类中使用了条件编译，所以QextSerialPort类既可以继承自
Win_QextSerialPort类，也可以继承自Posix_QextSerialPort类，所以使用了QextBaseType来表示。这一点
我们可以在qextserialport.h文件中看到。再说QextSerialPort类，其实它只是为了方便程序的跨平台编译，使用它可以在不同的
平台上，根据不同的条件编译继承不同的类。所以它只是一个抽象，提供了几个构造函数而已，并没有具体的内容。在qextserialport.h文件中的
条件编译内容如下：

#ifdef_TTY_POSIX_

#include“posix_qextserialport.h”

#define QextBaseTypePosix_QextSerialPort

#else

#include“win_qextserialport.h”

#define QextBaseTypeWin_QextSerialPort

#endif

所以，其实我们没有必要使用这个类，直接使用Win_QextSerialPort或Posix_QextSerialPort就可以了。当然如果
你想使用这个类，实现同样的源程序可以直接在Windows和Linux下编译运行，那么一定要注意在Linux下这里需要添加
#define _TTY_POSIX_ 。而我们这里为了使得程序更明了，所以没有使用该类，下面也就不再介绍它了。

QextSerialBase类继承自QIODevice类，它提供了操作串口所必需的一些变量和函数等，而
Win_QextSerialPort和Posix_QextSerialPort均继承自QextSerialBase
类，Win_QextSerialPort类添加了Windows平台下操作串口的一些功能，Posix_QextSerialPort类添加了
Linux平台下操作串口的一些功能。所以说，在Windows下我们使用Win_QextSerialPort类，在Linux下我们使用
Posix_QextSerialPort类。

3.在QextSerialBase类中还涉及到了一个枚举变量QueryMode。

它有两个值Polling和EventDriven
。QueryMode指的是读取串口的方式，下面我们称为查询模式，我们将Polling称为查询方式Polling，将EventDriven称为事件驱动方式。

事件驱动方式EventDriven就是使用事件处理串口的读取，一旦有数据到来，就会发出readyRead()信号，我们可以关联该信号来读取串口的数据。在事件驱动的方式下，串口的读写是异步的，调用读写函数会立即返回，它们不会冻结调用线程。

而查询方式Polling则不同，读写函数是同步执行的，信号不能工作在这种模式下，而且有些功能也无法实现。但是这种模式下的开销较小。我们需要自己建立定时器来读取串口的数据。

在Windows下支持以上两种模式，而在Linux下只支持Polling模式。

三、小结。

这里讲了这么多，最后要说的只是，我们在Qt中使用这个类编写串口程序，根据平台的不同只需要分别使用四个文件。

在Windows下是：

qextserialbase.cpp和qextserialbase.h
以及win_qextserialport.cpp和win_qextserialport.h

在Linux下是：

qextserialbase.cpp和qextserialbase.h
以及posix_qextserialport.cpp和posix_qextserialport.h

而在Windows下我们可以使用事件驱动EventDriven方式，也可以使用查询Polling方式，但是在Linux下我们只能使用查询Polling方式。

第二部分 在Windows下编写串口通信程序

我们的环境是Windowsxp，Qt4.6.3及Qt Creator2.0。

第一，下面我们首先使用事件驱动来实现串口通信。

1.新建工程。

我们在QtCreator中新建Qt Gui工程，命名为myCom，Base Class选择QWidget。

2.添加文件。

我们将那四个文件添加到工程文件夹中。如下图。

然后我们将这四个文件添加到工程中，在Qt
Creator的工程列表中的工程文件夹上点击鼠标右键，在弹出的菜单中选择“AddExisting Files”菜单。如下图。

我们在弹出的对话框中选中四个文件，按下“打开”按钮即可，如下图。

最终工程文件列表如下图。

3.更改界面。

我们将界面设计如下。

其中的TextBrowser 部件用来显示接收到的数据，Line Edit部件用来输入要发送的数据，Push
Button按钮用来发送数据。我们保持各部件的属性为默认值即可。

4. 我们在widget.h文件中进行对象及函数声明。

添加头文件包含：#include“win_qextserialport.h”

然后在private中声明对象：Win_QextSerialPort *myCom;

声明私有槽函数：

private slots:

voidon_pushButton_clicked(); //”发送数据”按钮槽函数

void readMyCom(); //读取串口

5.在widget.cpp文件中进行更改。

在构造函数中添加代码，完成后，构造函数内容如下：

Widget::Widget(QWidget*parent) :

QWidget(parent),

ui(newUi::Widget)

{

ui->setupUi(this);

myCom=
new Win_QextSerialPort(“COM1″,QextSerialBase::EventDriven);

//定义串口对象，指定串口名和查询模式，这里使用事件驱动EventDriven

myCom->open(QIODevice::ReadWrite);

//以读写方式打开串口

myCom->setBaudRate(BAUD9600);

//波特率设置，我们设置为9600

myCom->setDataBits(DATA_8);

//数据位设置，我们设置为8位数据位

myCom->setParity(PAR_NONE);

//奇偶校验设置，我们设置为无校验

myCom->setStopBits(STOP_1);

//停止位设置，我们设置为1位停止位

myCom->setFlowControl(FLOW_OFF);

//数据流控制设置，我们设置为无数据流控制

myCom->setTimeout(500);

//延时设置，我们设置为延时500ms,这个在Windows下好像不起作用

connect(myCom,SIGNAL(readyRead()),this,SLOT(readMyCom()));

//信号和槽函数关联，当串口缓冲区有数据时，进行读串口操作

}

实现槽函数：

void Widget::readMyCom()//读取串口数据并显示出来

{

QByteArray
temp = myCom->readAll();

//读取串口缓冲区的所有数据给临时变量temp

ui->textBrowser->insertPlainText(temp);

//将串口的数据显示在窗口的文本浏览器中

}

voidWidget::on_pushButton_clicked() //发送数据

{

myCom->write(ui->lineEdit->text().toAscii());

//以ASCII码形式将数据写入串口

}

6.此时，我们运行程序，效果如下。

可以看到，已经成功完成通信了。

（注：我们这里下位机使用的是单片机，它使用串口与计算机的COM1相连。单片机上运行的程序的功能是，接收到一个字符便向上位机发送一个字符串然后发送接收到的字符。）

两个重要问题的讲解：

一、关于数据接收。

我们想在程序中对接收的数据进行控制，但是readyRead()信号是一旦有数据到来就发射的，不过我们可以使用bytesAvailable()函数来检查已经获得的字节数，从而对数据接收进行控制。

（1）我们在widget.cpp中添加头文件包含：#include

然后在读串口函数中添加一行代码，如下：

void Widget::readMyCom() //读取串口数据并显示出来

{

qDebug()
<< “read:
“<<myCom->bytesAvailable()<<”bytes”;

//我们输出每次获得的字节数

QByteArray
temp = myCom->readAll();

ui->textBrowser->insertPlainText(temp);

}

运行程序，效果如下：

可以看到，我们获取的数据并不是一次获得的。

（2）利用上面的结论，我们可以让串口缓冲区拥有了一定的数据后再读取。

void Widget::readMyCom()

{

if(myCom->bytesAvailable()>=8 )

//如果可用数据大于或等于8字节再读取

{

qDebug()
<< “read:
“<<myCom->bytesAvailable()<<”bytes”;

QByteArray
temp = myCom->readAll();

ui->textBrowser->insertPlainText(temp);

}

}

运行程序，效果如下：

我们发送了两次数据，可以看到，这样实现了每8个字节读取一次，而最后剩余的不够8个字节的数据将会和后面的数据一起读出。

然后我们将8改为3，发送一次数据，效果如下：

改为7，发送两次数据，效果如下：

改为11，发送两次数据，效果如下：

改为17，发送三次数据，效果如下：

重要结论：我们发送一次数据，应该获得37字节的数据，然后我们对比上面的结果，发现了什么？是的，其实串口每次读取8字节的数据放到缓冲区，只有
数据总数小于8字节时，才会读取小于8字节的数据。为了再次验证我们的结论，我们可以将上面程序中的“>=”改为“==”，那么只有8的倍数才能读
取数据（当然这里37也可以），你可以测试一下。

关于接收数据方面，可以根据你自己的需要再去进行研究和改进，这里只是抛砖引玉。

二、关于发送数据。

我们也可以使用函数获取要发送的数据的大小，这里有个bytesToWrite()可以获取要发送的字节数。例如将发送数据更改如下：

voidWidget::on_pushButton_clicked() //发送数据

{

myCom->write(ui->lineEdit->text().toAscii());

qDebug()
<< “write:
“<<myCom->bytesToWrite()<<”bytes”;

//输出要发送的字节数

}

运行后效果如下：

当然，对于要发送的数据的大小我们不是很关心，而且它还有很多方法可以实现，这个还有个bytesWritten()信号函数来获取已经发送的数据的大小，不过好像它不是很好用。这里将它们提出来，只是供大家参考而已。

第二，使用查询方式Polling来实现串口通信。

这里再次说明，Polling方式是不能使用readyRead()信号的，所以我们需要自己设置定时器，来不断地读取缓冲区的数据。

1.我们在widget.h中声明一个定时器对象。

添加头文件包含：#include

添加private变量：QTimer *readTimer;

2.我们在widget.cpp文件中的构造函数中更改。

（1）将串口定义更改为：

myCom =
newWin_QextSerialPort(“COM1″,QextSerialBase::Polling);

//定义串口对象，指定串口名和查询模式，这里使用Polling

（2）定义定时器，并将以前的关联更改为定时器的关联。

readTimer = newQTimer(this);

readTimer->start(100);

//设置延时为100ms

connect(readTimer,SIGNAL(timeout()),this,SLOT(readMyCom()));

//信号和槽函数关联，延时一段时间，进行读串口操作

3.此时运行程序，便可以正常收发数据了。

重点：关于延时问题。

上面的程序中可以进行数据的接收了，但是好像中间的延时有点长，要等一会儿才能收到数据，而且即便我们将定时器改为10ms
也不行。问题在哪里呢？其实真正控制串口读写时间的不是我们的定时器，而是延时timeout。我们在构造函数中设置了延时：

myCom->setTimeout(500);

//延时设置，我们设置为延时500ms

我们前面说延时并不起作用，那是因为是在事件驱动的情况下，一旦有数据到来就会触发readyRead()信号，所以延时不起作用。但是现在，真正
控制串口读写数据间隔的就是这个函数。这里值得注意，我们现在所说的串口读写是指底层的串口读写，从上面的程序中我们也可以看到，我们每隔100ms去读
串口，确切地说，应该是去读串口缓冲区。而timeout才是正真的读取串口数据，将读到的数据放入串口缓冲区。所以如果timeout时间很长，即便我
们的定时器时间再短，也是读不到数据的。所以我们这里需要将timeout设置为较小的值，比如10。我们更改代码：

myCom->setTimeout(10);

这样再运行程序，我们就可以很快地获得数据了。

关于数据接收：事件驱动那里的结论依然有用，不过这里更多的是靠读取的时间间隔来控制。

关于发送数据：这时bytesToWrite()函数就不再那么好用了。

第三部分 在Linux下编写串口通信程序

我这里的环境是Ubuntu10.04，Qt 4.6.3和Qt Creator2.0
。上面已经提到，在Linux下只能使用Polling的方式读取串口数据，所以我们将上面Windows下的应用Polling的程序在Linux下重
新编译。我们使用Qt Creator打开该工程，然后进行下面的操作。

1.文件替换。

将工程中的win_qextserialport.cpp和win_qextserialport.h文件替换成posix_qextserialport.cpp和posix_qextserialport.h文件。

（1）我们先删除工程中的win_qextserialport.cpp和win_qextserialport.h文件。

在工程列表中用鼠标右击win_qextserialport.h，然后选择“Remove File”选项。如下图。

在弹出的对话框中我们选中“Deletefile permanently”选项，确保删除了工程文件夹中的文件。如下图。

然后我们使用同样的方法删除win_qextserialport.cpp文件。

（2）我们按照Windows下添加文件的方法，向工程中添加posix_qextserialport.cpp和posix_qextserialport.h文件。最终工程文件列表如下。

2.设置编码。

（这是因为两个系统使用的默认编码不同造成的，如果你那里没有该问题，可以跳过这一步）

现在我们打开widget.cpp文件，发现中文出现乱码，而且无法编辑。在编辑器最上面有一个黄色提示条和一个“Select
Encoding”按钮，我们点击该按钮。如下图。

在弹出的对话框中我们选择“GB2312”。按下“Reload with Encoding”按钮，中文就可以正常显示了。

3.更改程序。

在widget.h文件中：

将以前的#include“win_qextserialport.h”更改为#include“posix_qextserialport.h”

将以前的Win_QextSerialPort*myCom;更改为Posix_QextSerialPort*myCom;

在widget.cpp文件中：

将以前的myCom= new
Win_QextSerialPort(“COM1″,QextSerialBase::Polling);

更改为：myCom= new
Posix_QextSerialPort(“/dev/ttyS0″,QextSerialBase::Polling);

（这里一定要注意串口名称的写法。）

4.下面我们运行程序。

这时可能会出现以下提示。

错误是说一个函数的调用出现了问题。我们点击该错误，定位到出错的位置，然后将那个函数中的第一个参数删除即可。如下图。

5.再次运行程序，这时已经可以正常运行了。

6.小结

可以看到将Windows下的串口程序在Linux下重新编译是很简单的，我们只需要替换那两个文件，然后更改一下头文件包含，对象定义和串口名即可。

Ⅳ Linux C编程从初学到精通的目 录

第1部分 基础篇
第1章 Linux系统概述 1
1.1 什么是Linux 2
1.2 Linux系统特点及主要功能 2
1.2.1 Linux系统特点 3
1.2.2 Linux系统的主要功能 3
1.3 Linux的内核版本和发行版本 5
1.4 系统的安装 6
1.4.1 系统安装前的准备工作 6
1.4.2 从光盘安装Linux 6
1.4.3 从硬盘安装Linux 22
1.4.4 在虚拟机下安装Linux 22
1.5 Shell的使用 27
1.5.1 Shell简介 27
1.5.2 常见Shell的种类 28
1.5.3 Shell的简单使用 29
1.5.4 通配符 30
1.5.5 引号 31
1.5.6 注释符 33
1.6 Linux常用命令 33
1.6.1 与目录相关的命令 33
1.6.2 与文件相关的命令 34
1.6.3 与网络服务相关的命令 35
1.7 本章小结 35
实战演练 36
第2章 C语言编程基础 37
2.1 C语言的历史背景 38
2.2 C语言的特点 38
2.3 C语言的基本数据类型 39
2.3.1 整型 39
2.3.2 实型 40
2.3.3 字符型 41
2.4 运算符与表达式 43
2.4.1 算术运算符与算术表达式 43
2.4.2 赋值运算符与赋值表达式 44
2.4.3 逗号运算符与逗号表达式 45
2.5 C程序的3种基本结构 46
2.5.1 顺序结构 46
2.5.2 选择结构 47
2.5.3 循环结构 51
2.6 C语言中的数据输入与输出 54
2.6.1 字符输出函数putchar 54
2.6.2 字符输入函数getchar 54
2.6.3 格式输出函数printf 54
2.6.4 格式输入函数scanf 56
2.7 函数 57
2.7.1 函数的定义 57
2.7.2 函数的调用 58
2.7.3 变量的存储类别 59
2.8 数组 62
2.8.1 一维数组的定义和使用 63
2.8.2 二维数组的定义和使用 64
2.8.3 字符数组和字符串 65
2.8.4 常用字符串处理函数 66
2.9 指针 69
2.9.1 地址和指针 69
2.9.2 指针的定义和使用 70
2.9.3 数组与指针 71
2.9.4 字符串与指针 72
2.9.5 指向函数的指针 72
2.10 结构体和共用体 73
2.10.1 定义和引用结构体 73
2.10.2 结构体数组 74
2.10.3 指向结构体的指针 74
2.10.4 共用体 75
2.10.5 使用typedef定义类型 77
2.11 链表 77
2.11.1 链表概述 77
2.11.2 建立动态单向链表 78
2.11.3 单向链表的输出 80
2.11.4 对单向链表的删除操作 80
2.11.5 对单向链表的插入操作 81
2.11.6 循环链表 82
2.11.7 双向链表 82
2.12 位运算符和位运算 83
2.12.1 “按位与”运算符（&） 84
2.12.2 “按位或”运算符（|） 84
2.12.3 “取反”运算符（~） 84
2.12.4 “异或”运算符（^） 84
2.12.5 移位运算符（<<和>>） 85
2.12.6 位域 85
2.13 C语言预处理命令 86
2.13.1 宏定义 86
2.13.2 文件包含 87
2.13.3 条件编译 88
2.13.4 #error等其他常用预处理命令 89
2.14 本章小结 89
实战演练 89
第3章 vi与Emacs编辑器 91
3.1 vi的使用 92
3.1.1 启动与退出vi 92
3.1.2 vi的命令行模式 93
3.1.3 vi的插入模式 96
3.1.4 vi的底行模式 96
3.2 vi使用实例 97
3.3 Emacs的使用 100
3.3.1 启动与退出Emacs 101
3.3.2 Emacs下的基本操作 102
3.4 Emacs使用实例 107
3.5 本章小结 109
实战演练 109
第4章 gcc编译器与gdb调试器 110
4.1 gcc编译器简介 111
4.2 如何使用gcc 112
4.2.1 gcc编译初步 112
4.2.2 警告提示功能 114
4.2.3 优化gcc 116
4.2.4 连接库 119
4.2.5 同时编译多个源程序 120
4.2.6 管道 120
4.2.7 调试选项 121
4.3 gdb调试器 122
4.3.1 gdb简介 122
4.3.2 gdb常用命令 123
4.3.3 gdb调试初步 124
4.4 gdb的使用详解 126
4.4.1 调用gdb 127
4.4.2 使用断点 127
4.4.3 查看运行时数据 129
4.4.4 查看源程序 133
4.4.5 改变程序的执行 135
4.5 xxgdb调试器简介 138
4.6 本章小结 139
实战演练 139
第5章 make的使用和Makefile的编写 141
5.1 什么是make 142
5.1.1 make机制概述 142
5.1.2 make与Makefile的关系 144
5.2 Makefile的书写规则 147
5.2.1 Makefile的基本语法规则 148
5.2.2 在规则中使用通配符 149
5.2.3 伪目标 149
5.2.4 多目标 151
5.2.5 自动生成依赖性 151
5.3 Makefile的命令 152
5.4 变量 154
5.4.1 变量的基础 154
5.4.2 赋值变量 154
5.4.3 define关键字 156
5.4.4 override指示符 156
5.4.5 目标变量和模式变量 157
5.5 常用函数调用 158
5.5.1 字符串处理函数 158
5.5.2 文件名操作函数 162
5.5.3 循环函数 164
5.5.4 条件判断函数 165
5.5.5 其他常用函数 166
5.6 隐式规则 168
5.6.1 隐式规则举例 168
5.6.2 隐式规则中的变量 169
5.6.3 使用模式规则 170
5.7 本章小结 173
实战演练 173
第2部分 提高篇
第6章 文件I/O操作 174
6.1 Linux文件系统简介 175
6.1.1 Linux的文件系统结构 175
6.1.2 文件类型 176
6.1.3 文件访问权限 179
6.2 基于文件描述符的I/O操作 179
6.2.1 文件描述符 180
6.2.2 标准输入、标准输出和标准出错 180
6.2.3 文件重定向 181
6.2.4 文件的创建、打开与关闭 182
6.2.5 文件的定位 186
6.2.6 文件的读写 188
6.3 文件的属性操作 192
6.3.1 改变文件访问权限 192
6.3.2 改变文件所有者 193
6.3.3 重命名 193
6.3.4 修改文件长度 194
6.4 文件的其他操作 195
6.4.1 stat、fstat和lstat函数 195
6.4.2 p和p2函数 196
6.4.3 fcntl函数 197
6.4.4 sync和fsync函数 197
6.5 特殊文件的操作 198
6.5.1 目录文件的操作 198
6.5.2 链接文件的操作 201
6.5.3 管道文件的操作 204
6.5.4 设备文件 204
6.6 本章小结 205
实战演练 205
第7章 基于流的I/O操作 206
7.1 流与缓存 207
7.1.1 流和FILE对象 207
7.1.2 标准输入、标准输出和标准出错 207
7.1.3 缓存 207
7.1.4 对缓存的操作 210
7.2 流的打开与关闭 212
7.2.1 流的打开 212
7.2.2 流的关闭 214
7.2.3 流关闭前的工作 216
7.3 流的读写 216
7.3.1 基于字符的I/O 217
7.3.2 基于行的I/O 220
7.3.3 直接I/O 222
7.3.4 格式化I/O 224
7.4 本章小结 226
实战演练 227
第8章 进程控制 228
8.1 进程的基本概念 229
8.1.1 Linux进程简介 229
8.1.2 进程与作业 230
8.1.3 进程标识 230
8.2 进程控制的相关函数 232
8.2.1 fork和vfork函数 232
8.2.2 exec函数 237
8.2.3 exit和_exit函数 242
8.2.4 wait和waitpid函数 245
8.2.5 进程的一生 251
8.2.6 用户ID和组ID 251
8.2.7 system函数 253
8.3 多个进程间的关系 255
8.3.1 进程组 255
8.3.2 会话期 256
8.3.3 控制终端 257
8.4 本章小结 259
实战演练 259
第9章 信号 260
9.1 Linux信号简介 261
9.1.1 信号的基本概念 261
9.1.2 信号处理机制 265
9.2 信号操作的相关函数 267
9.2.1 信号的处理 267
9.2.2 信号的发送 274
9.2.3 信号的阻塞 282
9.2.4 计时器与信号 284
9.3 本章小结 286
实战演练 287
第10章 进程间通信 288
10.1 进程间通信简介 289
10.2 管道 290
10.2.1 管道的概念 290
10.2.2 管道的创建与关闭 291
10.2.3 管道的读写 292
10.3 命名管道 297
10.3.1 命名管道的概念 297
10.3.2 命名管道的创建 297
10.3.3 命名管道的读写 299
10.4 消息队列 303
10.4.1 消息队列的概念 303
10.4.2 消息队列的创建与打开 305
10.4.3 消息队列的读写 306
10.4.4 获得或设置消息队列属性 308
10.5 共享内存 312
10.5.1 共享内存的概念 312
10.5.2 共享内存的相关操作 313
10.6 信号量 318
10.6.1 信号量的概念 319
10.6.2 信号量集的相关操作 320
10.7 本章小结 325
实战演练 326
第11章 网络编程 327
11.1 网络编程的基础知识 328
11.1.1 计算机网络体系结构 328
11.1.2 传输控制协议TCP 333
11.1.3 用户数据报协议UDP 335
11.1.4 客户机/服务器模式 336
11.2 套接口编程基础 336
11.2.1 什么是套接口 337
11.2.2 端口号的概念 338
11.2.3 套接口的数据结构 338
11.2.4 基本函数 340
11.3 TCP套接口编程 343
11.3.1 TCP套接口通信工作流程 343
11.3.2 TCP套接口Client/Server程序实例 356
11.4 UDP套接口编程 360
11.4.1 UDP套接口通信工作流程 360
11.4.2 UDP套接口Client/Server程序实例 362
11.5 原始套接口编程 365
11.5.1 原始套接口的创建 365
11.5.2 原始套接口程序实例 365
11.6 本章小结 376
实战演练 376
第12章 Linux图形界面编程 377
12.1 Linux下的图形界面编程简介 378
12.1.1 Qt简介 378
12.1.2 GTK+简介 378
12.2 界面基本元件 381
12.2.1 一个简单的例子 381
12.2.2 窗口 383
12.2.3 标签 385
12.2.4 按钮 386
12.2.5 文本框 387
12.3 界面布局元件 389
12.3.1 表格 390
12.3.2 框 393
12.3.3 窗格 395
12.4 其他常用元件 398
12.4.1 进度条、微调按钮、组合框 398
12.4.2 单选按钮、复选按钮 402
12.4.3 下拉菜单 404
12.5 信号与回调函数 406
12.6 本章小结 409
实战演练 409
第3部分 实战篇
第13章 设计Linux下的计算器 411
13.1 软件功能分析 412
13.2 程序模块的划分 413
13.3 软件的具体实现 415
13.3.1 头文件 415
13.3.2 十六进制界面显示函数 416
13.3.3 十进制界面显示函数 417
13.3.4 八进制界面显示函数 418
13.3.5 二进制界面显示函数 419
13.3.6 进制间转换函数 420
13.3.7 信号处理模块 423
13.3.8 主函数 432
13.4 软件使用效果演示 438
13.5 本章小结 439
第14章 Linux平台下聊天软件的设计 440
14.1 软件功能概述 441
14.1.1 服务器端功能需求 441
14.1.2 客户端功能需求 442
14.1.3 错误处理需求 442
14.2 Glade集成开发工具简介 443
14.3 软件功能模块划分 444
14.3.1 服务器功能模块划分 444
14.3.2 客户端功能模块划分 445
14.3.3 消息标识的定义 445
14.3.4 消息结构体的设计 446
14.4 服务器程序的具体实现 447
14.4.1 服务器消息处理流程 447
14.4.2 服务器主要函数和变量 448
14.4.3 服务器消息处理模块的设计与实现 449
14.4.4 服务器数据存储的方法 450
14.4.5 用户注册流程 450
14.5 客户端程序的具体实现 451
14.5.1 客户端操作流程 451
14.5.2 客户端发送和接收消息流程 451
14.5.3 客户端主要函数和变量 452
14.5.4 客户端功能模块的设计与实现 453
14.6 聊天软件使用效果演示 455
14.7 本章小结 459
第15章 Linux远程管理工具的设计 460
15.1 软件功能概述 461
15.1.1 Webmin简介 461
15.1.2 软件总体设计 461
15.2 服务器端程序设计 463
15.2.1 服务器端工作流程 463
15.2.2 系统用户管理操作 464
15.2.3 系统用户组的管理操作 466
15.2.4 系统服务启动管理 468
15.2.5 DNS管理操作 469
15.2.6 Apache服务管理操作 471
15.2.7 FTP服务管理操作 474
15.3 客户端程序 475
15.3.1 连接界面 475
15.3.2 主界面 477
15.4 本章小结 479
第16章 Linux下简易防火墙软件的设计 480
16.1 Netfilter基础 481
16.1.1 什么是Netfilter 481
16.1.2 Netfilter的HOOK机制 482
16.1.3 HOOK的调用 485
16.1.4 HOOK的实现 486
16.1.5 IPTables简介 488
16.1.6 Netfilter可以实现的控制功能 489
16.2 软件设计概述 491
16.2.1 软件整体框架 491
16.2.2 管理端的设计 492
16.2.3 控制端的设计 493
16.3 用Netfilter设计控制端功能模块 495
16.3.1 ICMP管理控制模块 495
16.3.2 FTP管理控制模块 497
16.3.3 HTTP管理控制模块 499
16.3.4 模块的编译、加载与卸载 499
16.4 软件功能测试 501
16.5 本章小结 503
第17章 基于Linux的嵌入式家庭网关远程交互操作平台的设计 504
17.1 嵌入式技术简介 505
17.1.1 嵌入式系统的概念 505
17.1.2 嵌入式操作系统 506
17.1.3 嵌入式处理器 507
17.2 家庭网关的概念及其网络体系结构 509
17.2.1 智能家庭网络的概念 509
17.2.2 家庭网关的远程交互操作技术简介 510
17.2.3 嵌入式家庭网关的网络体系结构 510
17.3 嵌入式家庭网关的开发平台 511
17.3.1 S3C2410微处理器简介 511
17.3.2 交叉编译环境的建立 513
17.4 远程交互平台的设计 515
17.4.1 应用软件的开发模式 515
17.4.2 嵌入式Web服务器 516
17.4.3 通用网关接口CGI 519
17.5 Linux下软件模块的具体实现 520
17.5.1 登录验证模块 521
17.5.2 串口通信模块 521
17.5.3 中央空调控制模块 522
17.5.4 智能水表数据采集模块 528
17.5.5 试验结果 528
17.6 本章小结 529

Ⅵ CMAKE_RC_COMPILER 是什么东西

cmake vs qmakeqmake 是为 Qt 量身打造的，使用起来非常方便cmake 使用上不如qmake简单直接，但复杂换来的是强大的功能内置的 out-of source 构建。（目前QtCreator为qmake也默认启用了该功能，称：shadow build）为各种平台和场景提供条件编译可处理多个可执行文件情况，和很好配合 QtTest 工作如何选择?Using CMake to Build Qt Projects 一文中说：对简单的Qt工程，采用 qmake对复杂度超过 qmake 处理能力的，采用 cmake尽管如此，如果简单Qt的工程都不知道怎么用 cmake 构建，复杂的工程，就更不知道如何使用 cmake 了。还是从简单的学起吧简单的 Qt 程序#include <QtCore/QCoreApplication>#include <QtCore/QDebug>int main(int argc, char** argv){ QCoreApplication app(argc, argv); qDebug()<<"hello qt!"; app.exec();}如果不使用构建工具，直接调用编译器来编译的话，只需要类似这样的一条命令：g++ main.cpp -Ie:\Qt\4.7.0\include -o main -Le:\Qt\4.7.0\lib -lQtCore4指定头文件目录，以及需要链接的库qmakeqmake 需要一个 .pro 文件:CONFIG += qtQT -= guiSOURCES += main.cpp因为我们需要 Qt的库和头文件，所以需要 CONFIG += qt 。这是默认项，可直接去掉该行启用qt后，可以通过 QT -= gui 来进一步细调我们需要的模块默认是 core gui。我们不需要gui模块，故去掉。cmakecmake 需要一个 CMakeLists.txt 文件：PROJECT(example)FIND_PACKAGE(Qt4 REQUIRED)SET(QT_DONT_USE_QTGUI TRUE)INCLUDE(${QT_USE_FILE})ADD_EXECUTABLE(example main.cpp)TARGET_LINK_LIBRARIES(example ${QT_LIBRARIES})FIND_PACKAGE 来启用 Qt4默认使用了core 和 gui，故手动禁用 QTGUI这两行可以直接使用 FIND_PACKAGE(Qt4 COMPONENTS QtCore REQUIRED)，未指定的模块将被禁用包含一个CMake为Qt提供的配置文件，${QT_USE_FILE}变量是一个文件名添加可执行程序目标链接到 Qt 的库复杂一点考虑一个常规Qt程序：main.cppmainwindows.uimainwindows.hmainwindows.cpp如果手动编译的话：mainwindow.ui 需要使用 uic 预处理uic mainwindow.ui -o ui_mainwindow.hmainwindow.h 需要 moc 预处理moc mainwindow.h -o moc_mainwindow.cpp调用编译器进行编译g++ main.cpp mainwindow.cpp moc_mainwindow.cpp -Ie:\Qt\4.7.0\include -o main -Le:\Qt\4.7.0\lib -lQtCore4 -lQtGui4qmake使用 qmake 的的话，一个简单的 pro 文件TARGET = exampleTEMPLATE = appSOURCES += main.cpp mainwindow.cppHEADERS += mainwindow.hFORMS += mainwindow.uiHEADERS 中的文件是否需要 moc 进行预处理，qmake 运行时会根据其是否含有Q_OBJECT自动判断。这也是为什么 很多人添加Q_OBJECT宏后不重新运行qmake会出错误的原因。cmake看看相应的 cmake 的 CMakeLists.txt 文件PROJECT(example)CMAKE_MINIMUM_REQUIRED(VERSION 2.6)FIND_PACKAGE(Qt4 REQUIRED)INCLUDE(${QT_USE_FILE})INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})QT4_WRAP_CPP(example_MOCS mainwindow.h)QT4_WRAP_UI(example_UIS mainwindow.ui)ADD_EXECUTABLE(example main.cpp mainwindow.cpp ${example_MOCS})TARGET_LINK_LIBRARIES(example ${QT_LIBRARIES})需要 moc 的文件，用 QT4_WRAP_CPP 处理生成的文件放入变量 example_MOCS 中，最后一块链接到可执行程序需要 uic 的文件，用 QT4_WRAP_UI 处理Windows因为windows下链接时分为 console 和 windows 两个子系统，所以windows下有些问题需要特殊处理。用 qmake 时：默认是 windows 子系统可以通过 CONFIG += console 使用 console 子系统用 cmake 是：默认是 console 子系统使用 windows 子系统需要SET(QT_USE_QTMAIN TRUE)ADD_EXECUTABLE(example WIN32 main.cpp mainwindow.cpp ${example_MOCS})前者启用 qtmain.lib 库来提供windows下的 WinMain 入口函数。后者链接 windows 子系统再复杂一点main.cppmainwindows.uimainwindows.hmainwindows.cppmain.qrcmain.rc前面已经用到了Qt的 moc 和 uic，这次增加了资源系统 需要用 rccrcc main.qrc -o qrc_main.cpp同时，使用了windows下的资源文件 .rc (比如给程序添加图标)MVSC 中使用 rc.exe 对 .rc 文件进行处理MinGW 中使用 windres.exe 处理 .rc 文件qmakeTARGET = exampleTEMPLATE = libHEADERS = mainwindow.h widget.hSOURCES = main.cpp widget.cpp mainwindow.cppRESOURCES = main.qrcRC_FILE = main.rccmakePROJECT(example)CMAKE_MINIMUM_REQUIRED(VERSION 2.6)FIND_PACKAGE(Qt4 REQUIRED)SET(QT_USE_QTMAIN TRUE)INCLUDE(${QT_USE_FILE})INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})if(MINGW) set(CMAKE_RC_COMPILER_INIT windres) ENABLE_LANGUAGE(RC) SET(CMAKE_RC_COMPILE_OBJECT "<CMAKE_RC_COMPILER> <FLAGS> -O coff <DEFINES> -i <SOURCE> -o <OBJECT>")endif(MINGW)SET(example_SRCS main.cpp mainwindow.cpp widget.cpp res/main.rc)SET(example_MOC_SRCS mainwindow.h widget.h)QT4_WRAP_CPP(example_MOCS ${example_MOC_SRCS})QT4_ADD_RESOURCES(example_RCC_SRCS main.qrc)SET(example_SRCS ${example_SRCS} ${example_MOCS} ${example_RCC_SRCS})ADD_EXECUTABLE(example WIN32 main.cpp mainwindow.cpp ${example_SRCS})TARGET_LINK_LIBRARIES(example ${QT_LIBRARIES})对Qt的资源文件，使用 QT4_ADD_RESOURCES 来调用rcc进行预处理对 Windows 资源文件，直接和源文件一样，添加到列表中即可。只是：MinGW 下仅仅这么做还不行，上面的 MinGW 块用来修复这个问题Debug 与 Releaseqmake使用 qmake 时，可以在 pro 文件内分别为两种模式设置不同的选项。使用时，可以直接 make release 或 make debug 来编译不同的版本cmake不同于 qmake，由于 cmake 采用 out-of-source 方式。故：建立debug release两目录，分别在其中执行cmake -DCMAKE_BUILD_TYPE=Debug（或Release）需要编译不同版本时进入不同目录执行make对生成 msvc 工程的情况, CMAKE_BUILD_TYPE 不起作用。生成工程后使用IDE自带的模式选择。

Ⅶ c++中math中PI怎么用

从math.h的源文件中可以看到，需要首先在#include<math.h>前定义#define _MATH_DEFINES_DEFINED，才可以使用一些数学常量，并且可以看到pi的数学符号是M_PI。

因此，我们需要这样使用PI这个常数：

(7)qt条件编译扩展阅读：

从math.h的源文件还看到很多其他的数学常数，比如ln2,ln10,lge,lg2等等。这些都可以使用特定的数学符号来表示这些常量。

math.h中使用了条件编译指令# if defined...，在图一的第一行。

这里便是预处理指令，它是以#号开头的代码行。#号必须是该行除了任何空白字符外的第一个字符。#后是指令关键字，在关键字和#号之间允许存在任意个数的空白字符。整行语句构成了一条预处理指令，该指令将在编译器进行编译之前对源代码做某些转换。

下面是部分预处理指令：

#空指令，无任何效果

#include包含一个源代码文件

#define定义宏

#undef取消已定义的宏

#if如果给定条件为真，则编译下面代码

#ifdef如果宏已经定义，则编译下面代码

#ifndef如果宏没有定义，则编译下面代码

#elif如果前面的#if给定条件不为真，当前条件为真，则编译下面代码

#endif结束一个#if……#else条件编译块

#error停止编译并显示错误信息

Ⅷ qt如何设置宏区分同一个平台多套件编译

在pro里面定义一个宏，然后在代码中根据这个宏进行条件编译。

下面是一个示例：

网页链接

Ⅸ #ifdef 与#endif 在函数中的作用及其用法

条件编译的宏，根据宏定义指定变量与否来决定是否编译被
#ifdef和#endif所包括进来的整段语句块。