#include "stdio.h"

int a=0;

int b;

static char c;

int main(int argc,char *argv[])

{

char d=4;

static short e;

a++;

b=100;

c=(char)++a;

e=(++d)++;

printf("a=%d, b=%d, c=%d, d= %d, e=%d",a,b,c,d,e);

return 0;

}

a) 写出程序输出

b) 编译器如果安排各个变量(a,b,c,d)在内存中的布局(eg. stack,heap,data section,bss section),最好用图形方式描述。

答案：

int a=0; // data section
int b; // data section
static char c; // BSS
int main(int argc,char *argv[])
{   

char d=4; // stack
static short e; // BSS

｝

a=2,b=100,c=2,d=6,e=5

2、中断是嵌入式系统中重要的组成部分，这导致了许多编译开发商提供一种扩展：让标准C支持中断，产生了一个新的关键字__interrupt。下面的代码就使用了__interrupt关键字去定义了一个中断服务子程序(ISR),请评论以下这段代码。

 __interrupt double compute_area(double radius)
 {
 double area = PI * radius *radius;
 printf("nArea = %f", area);
 return area;
}

答案：

a)ISR不能返回一个值；
b)ISR不能传递参数；
c)浮点一般都是不可重入的；在许多的处理器/编译器中，浮点一般都是不可重入的。有些处理器/编译器需要让额处的寄存器入栈，有些处理器/编译器就是不允许在ISR中做浮点运算。此外，ISR应该是短而有效率的，在ISR中做浮点运算是不明智的
d)printf函数有重入和性能上的问题。

3、关键字volatile在编译时有什么含义?并给出三个不同使用场景的例子(可以伪代码或者文字描述)。

答案：

用volatile关键字定义变量，相当于告诉编译器，这个变量的值会随时发生变化，每次使用时都需要去内存里重新读取它的值，并不要随意针对它作优化。建议使用volatile变量的场所：
(1) 并行设备的硬件寄存器 （如：状态寄存器）
(2) 一个中断服务子程序中会访问到的非自动变量（全局变量） (Non-automatic variables)
(3) 多线程应用中被几个任务共享的变量

回答不出这个问题的人是不会被雇佣的。我认为这是区分C程序员和嵌入式系统程序员的最基本的问题。搞嵌入式的家伙们经常同硬件、中断、RTOS等等打交道，所有这些都要求用到volatile变量。不懂得volatile的内容将会带来灾难。
假设被面试者正确地回答了这是问题（嗯，怀疑是否会是这样），我将稍微深究一下，看一下这家伙是不是直正懂得volatile完全的重要性。
1)一个参数既可以是const还可以是 volatile吗？解释为什么。
2); 一个指针可以是volatile 吗？解释为什么。
3); 下面的函数有什么错误：

int square(volatile int *ptr)
{
        return *ptr * *ptr;
}

下面是答案：
1)是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。
2); 是的。尽管这并不很常见。一个例子是当一个中服务子程序修该一个指向一个buffer的指针时。
3) 这段代码有点变态。这段代码的目的是用来返指针*ptr指向值的平方，但是，由于*ptr指向一个volatile型参数，编译器将产生类似下面的代码：

int square(volatile int *ptr) 
{
    int a,b;
    a = *ptr;
    b = *ptr;
    return a * b;
}

由于*ptr的值可能被意想不到地该变，因此a和b可能是不同的。结果，这段代码可能返不是你所期望的平方值！正确的代码如下：

long square(volatile int *ptr) 
{
    int a;
    a = *ptr;
    return a * a;
}

4、C语言中static关键字的具体作用有哪些

答案：

在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。
在模块内（但在函数体外），一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。
在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用。
static全局变量与普通的全局变量有什么区别：static全局变量只初使化一次，防止在其他文件单元中被引用;
static局部变量和普通局部变量有什么区别：static局部变量只被初始化一次，下一次依据上一次结果值；
static函数与普通函数有什么区别：static函数在内存中只有一份，普通函数在每个被调用中维持一份拷贝

5、下面三种变量声明有何区别?请给出具体含义

int const *p;

int* const p;

int const* const p;

答案：

一个指向常整型数的指针
一个指向整型数的常指针
一个指向常整型数的常指针

6、对于整形变量A=0x12345678,请画出在little endian及big endian的方式下在内存中是如何存储的。

答案：

little endian             big endian 
高地址--〉 0x12      低地址--〉 0x12
               0x34                     0x34
               0x56                     0x56
低地址--〉 0x78      高地址--〉 0x78

7、在ARM系统中，函数调用的时候，参数是通过哪种方式传递的?

答案：

参数<=4时候，通过R0~R3传递，>4的通过压栈方式传递

8、中断(interrupt,如键盘中断)与异常(exception,如除零异常)有何区别?

答案：

异常：在产生时必须考虑与处理器的时钟同步，实践上，异常也称为同步中断。在处理器执行到由于编程失误而导致的错误指令时，或者在执行期间出现特殊情况(如缺页)，必须靠内核处理的时候，处理器就会产生一个异常。
所谓中断应该是指外部硬件产生的一个电信号，从cpu的中断引脚进入，打断cpu当前的运行；
所谓异常，是指软件运行中发生了一些必须作出处理的事件，cpu自动产生一个陷入来打断当前运行，转入异常处理流程。

9、用预处理指令#define 声明一个常数，用以表明1年中有多少秒（忽略闰年问题）

答案：

#define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL
我在这想看到几件事情：
1) #define 语法的基本知识（例如：不能以分号结束，括号的使用，等等）
2)懂得预处理器将为你计算常数表达式的值，因此，直接写出你是如何计算一年中有多少秒而不是计算出实际的值，是更清晰而没有代价的。
3) 意识到这个表达式将使一个16位机的整型数溢出-因此要用到长整型符号L,告诉编译器这个常数是的长整型数。
4) 如果你在你的表达式中用到UL（表示无符号长整型），那么你有了一个好的起点。记住，第一印象很重要。

10、用变量a给出下面的定义
a) 一个整型数（An integer） 
b)一个指向整型数的指针（ A pointer to an integer） 
c)一个指向指针的的指针，它指向的指针是指向一个整型数（ A pointer to a pointer to an intege）r 
d)一个有10个整型数的数组（ An array of 10 integers） 
e) 一个有10个指针的数组，该指针是指向一个整型数的。（An array of 10 pointers to integers） 
f) 一个指向有10个整型数数组的指针(A pointer to an array of 10 integers)
g) 一个指向函数的指针，该函数有一个整型参数并返回一个整型数 (pointer to a function that takes an integer as an argument and returns an integer） 
h) 一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数(An array of ten pointers to functions that take an integer argument and return an integer）

答案：

a) int a; 
b) int *a;
c) int **a;
d) int a[10];
e) int *a[10];
f) int (*a)[10];
g) int (*a)(int) ; 
h) int (*a[10])(int) ; 

11、下面的声明都是什么意思？

const int a;
int const a;
const int *a;
int * const a;
int const * a const;

答案：
前两个的作用是一样，a是一个常整型数。第三个意味着a是一个指向常整型数的指针（也就是，整型数是不可修改的，但指针可以）。第四个意思a是一个指向整型数的常指针（也就是说，指针指向的整型数是可以修改的，但指针是不可修改的）。最后一个意味着a是一个指向常整型数的常指针（也就是说，指针指向的整型数是不可修改的，同时指针也是不可修改的）。如果应试者能正确回答这些问题，那么他就给我留下了一个好印象。顺带提一句，也许你可能会问，即使不用关键字 const，也还是能很容易写出功能正确的程序，那么我为什么还要如此看重关键字const呢？我也如下的几下理由：
1) 关键字const的作用是为给读你代码的人传达非常有用的信息，实际上，声明一个参数为常量是为了告诉了用户这个参数的应用目的。如果你曾花很多时间清理其它人留下的垃圾，你就会很快学会感谢这点多余的信息。（当然，懂得用const的程序员很少会留下的垃圾让别人来清理的。）
2) 通过给优化器一些附加的信息，使用关键字const也许能产生更紧凑的代码。
3) 合理地使用关键字const可以使编译器很自然地保护那些不希望被改变的参数，防止其被无意的代码修改。简而言之，这样可以减少bug的出现。

12、下面的代码输出是什么，为什么？

void foo(void)
{
    unsigned int a = 6;
    int b = -20;
    (a+b > 6) ? puts("> 6") : puts("<= 6");
}

这个问题测试你是否懂得C语言中的整数自动转换原则，我发现有些开发者懂得极少这些东西。不管如何，这无符号整型问题的答案是输出是 ">6"。原因是当表达式中存在有符号类型和无符号类型时所有的操作数都自动转换为无符号类型。因此-20变成了一个非常大的正整数，所以该表达式计算出的结果大于6。这一点对于应当频繁用到无符号数据类型的嵌入式系统来说是丰常重要的。

#define dPS struct s *
typedef struct s * tPS;

以上两种情况的意图都是要定义dPS 和 tPS 作为一个指向结构s指针。哪种方法更好呢？（如果有的话）为什么？

这是一个非常微妙的问题，任何人答对这个问题（正当的原因）是应当被恭喜的。答案是：typedef更好。思考下面的例子：

dPS p1,p2;
tPS p3,p4;

第一个扩展为

struct s * p1, p2;.
上面的代码定义p1为一个指向结构的指，p2为一个实际的结构，这也许不是你想要的。第二个例子正确地定义了p3 和p4 两个指针。晦涩的语法

14、写出判断ABCD四个表达式的是否正确, 若正确, 写出经过表达式中 a的值(3分)
int a = 4;
(A)a += (a++); (B) a += (++a) ;(C) (a++) += a;(D) (++a) += (a++);
a = ?
答案：

C 错误，左侧不是一个有效变量，不能赋值，可改为(++a) += a;
改后答案依次为9,10,10,11

15、某32位系统下, C++程序，请计算sizeof 的值(5分).
char str[] = “www.ibegroup.com”
char *p = str ;
int n = 10;
请计算
sizeof (str ) = ？（1）
sizeof ( p ) = ？（2）
sizeof ( n ) = ？（3）
void Foo ( char str[100]){
请计算
sizeof( str ) = ？（4）
}
void *p = malloc( 100 );
请计算
sizeof ( p ) = ？（5）

答案：

（1）17 （2）4 （3） 4 （4）4 （5）4

内存操作

mw 0xc3000000 FF

mw 0xc3000000 FF 1000

md.b 0xe3000000  0x100000

md.w 0xe3000000  0x100000 

spi操作 （最小擦除单位为block）

sf read 0xe3000000 0 0x100000

md.b 0xe3000000  0x100000

sf read e30f0000 80000 100

md.w e30f0000 100

sf write e30E0000 0x80000 0x100000

sf erase 80000 10000

sd卡操作

run_command("mmc rescan 0", 0);
run_command("mmcinfo", 0);
run_command("fatls mmc 0", 0);

run_command("fatload mmc 0 0xc3000000 uboot-logo.bmp ", 0);

 把cf卡（fat格式）根目录中uboot-logo.bmp（大小142368 bytes）文件拷贝到spi的0x80000开始的地址上并且查看是否写正确：

u-boot> mmc rescan 0

u-boot> mmcinfo

u-boot> fatls mmc 0

u-boot> fatload mmc 0 0xc3000000 uboot-logo.bmp

u-boot> sf write 0xc3000000 0x80000 0x22c20

u-boot> sf read 0xc4000000 0x80000 0x22c20

u-boot> md.b 0xc4000000 0x22c20

VirtualBox虚拟硬盘的增大

原文：http://hi.baidu.com/jlgwxq/blog/item/35885b46ca1c2d8fb2b7dcea.html

VirtualBox虚拟机功能确实比较强大，不过有个缺点就是它的虚拟硬盘大小的上限在新建的时候就确定下来了，不能再扩大或缩小。我就因此吃过亏，将虚拟硬盘大小设置成6G，结果不够用。怎么办？重新再分配一个新盘，然后重装一次系统？显然，这并不可取，因为需要耗费大量的时间。

没办法网上找，果然找到了一个比较好的解决方案。基本步骤如下：

1. 在VirtualBox的媒质管理器中新建一个硬盘，大小要足够大，我分配的是20G。

2. 从网上下载GParted LiveCD（网址是：http://gparted.sourceforge.net/），我下载的是0.5.2.9，好象最新版的还存在一个严重的问题。

3.将GParted LiveCD的ISO文件引入到VirtualBox中，并在虚拟机中加载，同时还将原虚拟硬盘和新虚拟硬盘同时加载。我是将原盘引入到SATA 0，新盘引入到SATA 1。必须要说明的是，光驱启动要设置成优先。

4. 虚拟机从光盘启动了，一路碰到问题就直接按回车就进入了一个简陋的linux GUI环境中。

5. 打开Terminal终端程序（点击屏幕上方的大图标），在命令行中输入： dd if=/dev/sda of=/dev/sdb 这就相当于是包括MBR的全盘拷贝，时间会比较长，需耐心等待。要特别注意的是/dev/sda对应的是原盘，/dev/sdb对应的是新盘，不要弄错了，否则鸡飞蛋打，哭都来不及。关于这两盘各对应的是什么，可以在GParted程序中看出来，一定要在命令执行前搞清楚，切记。

6. 最好是重启一下虚拟机。

7. 打开GParted程序，可以看到新盘中的分区大小和原盘一模一样，显然这是不对的，需要调整分区的大小。这个调整过程很简单，可以直观地进行GUI操作。我这里的情况是新盘有两个分区，一个主分区5G左右，一个交换分区500M左右。先将交换分区删掉，然后扩大主分区至几乎最大（留500M左右给交换分区），最后，重新分配交换分区。

8. 最后，别忘了在GParted程序中，将新盘设置成可启动的。也就是"Manage Flags"中的一个"Boot"项要选上。

执行完上述步骤之后，关虚拟机，然后重新配置虚拟机，将光盘和原硬盘都移除掉，只用新盘，再重新启动。结果，新盘上的系统确实可以正常工作，而且原盘上的内容都完整无缺地复制过来了。耗时近1小时，迁移成功！

参考贴子： http://hi.baidu.com/jerry_916/blog/item/e0334553d6354e020cf3e38e.html

  原文：http://www.cnblogs.com/dkblog/archive/2011/04/02/2003822.html

Linux中的shell有多种类型，其中最常用的几种是Bourne   shell（sh）、C   shell（csh）和Korn   shell（ksh）。三种shell各有优缺点。

Bourne   shell是UNIX最初使用的shell，并且在每种UNIX上都可以使用。Bourne   shell在shell编程方面相当优秀，但在处理与用户的交互方面做得不如其他几种shell。

Linux操作系统缺省的shell是Bourne   Again   shell，它是Bourne   shell的扩展，简称Bash，与Bourne   shell完全向后兼容，并且在Bourne   shell的基础上增加、增强了很多特性。Bash放在/bin/bash中，它有许多特色，可以提供如命令补全、命令编辑和命令历史表等功能，它还包含了很多C   shell和Korn   shell中的优点，有灵活和强大的编程接口，同时又有很友好的用户界面。

GNU/Linux 操作系统中的 /bin/sh 是 bash（Bourne-Again Shell）的符号链接，

    但鉴于 bash 过于复杂，有人把 ash 从 NetBSD 移植到 Linux 并更名为 dash（Debian Almquist Shell），并建议将 /bin/sh 指向它，以获得更快的脚本执行速度。Ubuntu 号称自从他们在 6.10 版里这样做了以后，系统启动速度有了明显的提升。Debian 计划在下一个发行版（代号 lenny）中也将 dash 作为默认的 /bin/sh。

/bin/sh与/bin/bash的细微区别

原文：不详

在shell脚本的开头往往有一句话来定义使用哪种sh解释器来解释脚本。
目前研发送测的shell脚本中主要有以下两种方式：
(1) #!/bin/sh
(2) #!/bin/bash
在这里求教同福客栈的各位大侠们一个问题：
以上两种方式有什么区别？对于脚本的实际运行会产生什么不同的影响吗？

脚本test.sh内容：
#!/bin/sh
source pcy.sh #pcy.sh并不存在
echo hello
执行./test.sh，屏幕输出为：
./test.sh: line 2: pcy.sh: No such file or directory
由此可见，在#!/bin/sh的情况下，source不成功，不会运行source后面的代码。
修改test.sh脚本的第一行，变为#!/bin/bash，再次执行./test.sh，屏幕输出为：
./test.sh: line 2: pcy.sh: No such file or directory
hello
由此可见，在#!/bin/bash的情况下，虽然source不成功，但是还是运行了source后面的echo语句。
但是紧接着我又试着运行了一下sh ./test.sh，这次屏幕输出为：
./test.sh: line 2: pcy.sh: No such file or directory
表示虽然脚本中指定了#!/bin/bash，但是如果使用sh 方式运行，如果source不成功，也不会运行source后面的代码。

为什么会有这样的区别呢？

junru同学作了解释

1. sh一般设成bash的软链
[work@zjm-testing-app46 cy]$ ll /bin/sh
lrwxrwxrwx 1 root root 4 Nov 13 2006 /bin/sh -> bash
2. 在一般的linux系统当中（如redhat），使用sh调用执行脚本相当于打开了bash的POSIX标准模式
3. 也就是说 /bin/sh 相当于 /bin/bash --posix

所以，sh跟bash的区别，实际上就是bash有没有开启posix模式的区别

so，可以预想的是，如果第一行写成 #!/bin/bash --posix，那么脚本执行效果跟#!/bin/sh是一样的（遵循posix的特定规范，有可能就包括这样的规范：“当某行代码出错时，不继续往下解释”）


例如：
[root@localhost yuhj]# head -n1 x.sh
#!/bin/sh
[root@localhost yuhj]# ./x.sh

./x.sh: line 8: syntax error near unexpected token `<'
./x.sh: line 8: ` while read line; do { echo $line;((Lines++)); } ; done < <(route -n)'
[root@localhost yuhj]#



[root@localhost yuhj]# head -n1 x.sh
#!/bin/bash
[root@localhost yuhj]#./x.sh

Kernel IP routing table
Destination Gateway Genmask Flags Metric Ref Use Iface
192.168.202.0 0.0.0.0 255.255.255.0 U 0 0 0 eth0
0.0.0.0 192.168.202.2 0.0.0.0 UG 0 0 0 eth0
Number of lines read = 4
[root@localhost yuhj]#


[root@localhost yuhj]# head -n1 x.sh
#!/bin/bash --posix
[root@localhost yuhj]#
[root@localhost yuhj]# ./x.sh

./x.sh: line 8: syntax error near unexpected token `<'
./x.sh: line 8: ` while read line; do { echo $line;((Lines++)); } ; done < <(route -n)'



[root@localhost yuhj]# whereis sh bash
sh: /bin/sh /usr/share/man/man1/sh.1.gz /usr/share/man/man1p/sh.1p.gz
bash: /bin/bash /usr/share/man/man1/bash.1.gz

[root@localhost yuhj]# ll /bin/sh /bin/bash
-rwxr-xr-x 1 root root 735004 May 25 2008 /bin/bash
lrwxrwxrwx 1 root root 4 Jan 29 00:39 /bin/sh -> bash
[root@localhost yuhj]#

以下两种方式均采用免费软件，很多nfs server软件都是收费。

方法一：

Cygwin环境下NFS服务器的安装 

原文：http://blog.csdn.net/meidaoli168/article/details/4444151
 
运行Cygwin后，拷贝要安装的NFS服务器安装包（在cygwin-install中）到cygwin/tmp目录下

（1）解压安装包
  cd / 一定要回到根目录下解压安装NFS服务器
tar xvjf nfs-server-2.3-5.tar.bz2

（2）配置NFS Server
  /usr/bin/nfs-server-config
执行后会显示安装信息，点回车安装。注：若为XP系统时，需要创建用户名和密码，用户名和密码要与XP的管理员用户名和密码相同

（3）设置主机访问控制
编辑文件/etc/hosts.allow

设置任何用户都可以访问nfs服务时，在文件中增加行：
nfsd： ALL

也可以特别指定某个IP地址的用户访问nfs服务时，只需增加行如：
nfsd： 192.192.192.100 注：只增加这行即可 

如果特别指定某个子网地址的用户访问nfs服务时，只需增加行如：
nfsd： 192.192.0.0/255.255.0.0 注：只增加这行即可

编辑文件/etc/hosts.deny
如果Cygwin中没有其它网络服务，则注释本文件中的所有行。

（4）设置主机共享目录
编辑文件/etc/exports
可分行输入需要共享的路径及目录，共享一个/home/Administrator/nfs_share目录增加类似一下的行：
/home/Administrator/nfs_share 192.192.192.0/255.255.255.0(rw,no_root_squash)
表示在192.192.192子网上共享/home/Administrator/nfs_share目录，该目录可读写（rw)。

（5）启动NFS服务
可以在Cygwin下执行以下命令启动服务:
cygrunsrv -S portmap
cygrunsrv -S nfsd
cygrunsrv -S mountd

也可以通过打开Windows控制面板--管理工具--服务，选择portmap、mountd和nfs服务并启动，这等效以上三条启动命令。
启动之后可以使用以下命令检查服务是否成功运行：
/usr/sbin/showmount
如果输出报告时某服务启动失败，请直接回到根目录/重新安装NFS server软件包。

 方法二： 

微软提供的NFS Server软件

 原文：不详 

一、c#结构体
 
1、定义与C++对应的C#结构体

 
在c#中的结构体不能定义指针，不能定义字符数组，只能在里面定义字符数组的引用。
C++的消息结构体如下：
//消息格式 4+16+4+4= 28个字节
struct cs_message
{
    u32_t        cmd_type;
    char username[16];
    u32_t        dstID;
    u32_t        srcID;
};
 
C#定义的结构体如下:
 
[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct my_message
{
    public UInt32  cmd_type;

    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 16)]
    public string username;    

    public UInt32  dstID;

    public UInt32  srcID;

    public my_message(string s)
    {
        cmd_type = 0;
        username = s;
        dstID = 0;
        srcID = 0;
    }
}
 
在C++的头文件定义中，使用了 #pragma pack 1 字节按1对齐，所以C#的结构体也必须要加上对应的特
性，LayoutKind.Sequential属性让结构体在导出到非托管内存时按出现的顺序依次布局,而对于C++的
char数组类型，C#中可以直接使用string来对应，当然了，也要加上封送的特性和长度限制。

2、结构体与byte[]的互相转换
 
定义一个类，里面有2个方法去实现互转：
 
public class Converter
{
    public Byte[] StructToBytes(Object structure)
    {

        Int32 size = Marshal.SizeOf(structure);
        Console.WriteLine(size);
        IntPtr buffer = Marshal.AllocHGlobal(size);
        try
        {
            Marshal.StructureToPtr(structure, buffer, false);
            Byte[] bytes = new Byte[size];
            Marshal.Copy(buffer, bytes, 0, size);
            return bytes;
        }
        finally
        {
            Marshal.FreeHGlobal(buffer);
        }
    }

    public Object BytesToStruct(Byte[] bytes, Type strcutType)
    {
        Int32 size = Marshal.SizeOf(strcutType);
        IntPtr buffer = Marshal.AllocHGlobal(size);
        try
        {
            Marshal.Copy(bytes, 0, buffer, size);
            return Marshal.PtrToStructure(buffer, strcutType);
        }
        finally
        {
            Marshal.FreeHGlobal(buffer);
        }
    }
}
 
3、测试结果：
 
static void Main(string[] args)
{
    //定义转换类的一个对象并初始化
    Converter Convert = new Converter();

    //定义消息结构体
    my_message m;

    //初始化消息结构体
    m = new my_message("yanlina");
    m.cmd_type = 1633837924;
    m.srcID = 1633837924;
    m.dstID = 1633837924;

    //使用转换类的对象的StructToBytes方法把m结构体转换成Byte
    Byte[] message = Convert.StructToBytes(m);
    //使用转换类的对象的BytesToStruct方法把Byte转换成m结构体
    my_message n = (my_message)Convert.BytesToStruct(message, m.GetType());
    //输出测试
    Console.WriteLine(Encoding.ASCII.GetString(message));
    Console.WriteLine(n.username);
}
 
结构体的size是28个字节和c++的结构体一样，同时可以将结构体和字节数组互转，方便UDP的发送和接收。

本文来自CSDN博客，转载请标明出处：
http://blog.csdn.net/huxiangyang4/archive/2010/08/31/5853247.aspx

值传递：传的是对象的值拷贝。(即函数内参数对象是调用时传递的对象的栈中对象的拷贝。)
引用传递：传的是栈中对象的地址。(即函数内参数对象与调用时传递的对象完全是同一栈中对象。)
现在用例子来说明传值跟传地址的不同：

private void button2_Click(object sender, System.EventArgs e)
...{
  StringBuilder strb1 = new StringBuilder();
  StringBuilder strb2 = new StringBuilder();
  Test1(strb1);
  Test2(ref strb2);
  string str1 = strb1.ToString(); //str1值:"A"
  string str2 = strb2.ToString(); //str2值:"BC"
}

void Test1(StringBuilder strb)
...{
  //strb和strb1是两个栈中对象，但指向相同的地址，这个操作是改变堆中对象
  strb.Append("A");

  //这里将strb指向一个新的堆中对象，所以后面的操作与strb1指向的栈中对象无关
  strb = new StringBuilder("B");
  strb.Append("C");
}

void Test2(ref StringBuilder strb)
...{
  //这里的strb和strb2是同一个栈中对象，所以改变strb的值使其指向另一个对象也等于改变strb2
  strb = new StringBuilder("B");
  strb.Append("C");
}

常用的绘图方式，但是压缩算法太差，大图压缩失真严重，并且支持图片类型太少,支持bmp.
一些绘图方法参考另一文章:图片镂空算法集合

CxImage:

是一个开源库，功能强大，其官方主页http://www.xdp.it/cximage/
常用的5种:bmp,gif,png,jpg,ico
其他类型:tif,tga,pcx,wbmp,wmf,jp2,jpc,pgx,pnm,ras,jbg,mng,ska,raw
CxImage压缩算法较好，绘图速度快,4400*3000左右像素图片，容量3M左右，压缩到50*50，在快速拉动图片，并移动时，一点也不卡。

 VS7.1环境配置
 lib路径:在工程配置-&gt;连接器-&gt;常规-&gt;附加目录库
 加载lib:在工程配置-&gt;连接器-&gt;输入-&gt;附加依赖项
 cximage.lib
 jasper.lib
 jbig.lib
 Jpeg.lib
 png.lib
 Tiff.lib
 zlib.lib
 mng.lib
 libdcr.lib

 头文件路径:在工程配置c/c++-&gt;常规-&gt;附加包含目录
 使用：只需要包含"xImage.h"

 CxImage image;
 image.Load()，CreateFromHBITMAP()等函数导入图片
 image.Stretch(HDC,x,y,width,height);

GDI+:

同样功能强大，支持：bmp,jpg,gif,tiff,png.图片转换之前的算法应该是最好的，用大图去压缩，图片效果明显要比前两者好。
但是画大图时，速度太慢.比如以上4400*3000的图片，压缩到50*50,画图时间竟然是0.15秒，如果放在快速更新，或者移动的处理时，明显会延迟.

 使用前，需要在APP文件中初使化GDI+
 DWORD m_gdiplusToken;
 CGameApp::InitInstance()
 {
   Gdiplus::GdiplusStartupInput gdiplusStartupInput;
  Gdiplus::GdiplusStartup(&amp;m_gdiplusToken, &amp;gdiplusStartupInput, NULL);
 }
 int  CGameApp::ExistInstance()
 {
  Gdiplus::GdiplusShutdown(m_gdiplusToken);
  return 0;
 }

 Bitmap * pBmp = Bitmap::FromHBITMAP() 或者 Bitmap::FromFile() 等函数导入图片
 Graphics gr(HDC);
 gr.DrawImage(pBmp,x,y,Width,Height);

总结：

      1、一般绘图用GDI
      2、需要不同类型的图片格式，并且要快速绘图的用CxImage
      3、需要不同类型的图片格式，且要高质量图片效果的用GDI+

本文来自：http://blog.csdn.net/xuweiqun/archive/2009/07/20/4363627.aspx

首先说说什么类型是值类型，例如：int、float、bool之类的基础类型，以及用struct定义 的类型，如：DateTime。除此外，如 string，数组，以及用class定义的类型等都是引用类型。对于C#来说，很难罗列出所有类型进行一一分别，这需要自己在编码过程中进行分析总结。
 

       为了更好地说明两种类型之间的区别，借用如下的表格来说明:

  值类型 引用类型
内存分配地点 分配在栈中 分配在堆中
效率 效率高，不需要地址转换 效率低，需要进行地址转换
内存回收 使用完后，立即回收 使用完后，不是立即回收，等待GC回收
赋值操作 进行复制，创建一个同值新对象 只是对原有对象的引用
函数参数与返回值 是对象的复制 是原有对象的引用，并不产生新的对象
类型扩展 不易扩展 容易扩展，方便与类型扩展

通过如上细致对比，大家对于值类型和引用类型有个清楚的概念。

不过，无论是对于值类型还是引用类型来说，对于其作为函数参数或者返回值的时候，都是容易犯错误的地方。

对于值类型来说，当其 作为函数参数的时候，希望在函数中被修改，那么直接如下操作是不能被修改的:

public void Increment( int i )   
{   
　 i++;   
}  

要想在函数中对传进去的参数做真正的修改，需要借助于ref这个关键字，那么正确的形式如下:

public void Increment( ref int i )   
{   
　i++;   
}  

        也就是说，如果需要在函数中对值类型参数进行修改，需要用ref或者out进行标识才能真正实现。

而对于引用 类型来说，当其作为函数参数的时候，它所遇到的情况恰恰与值类型相反，即不希望在函数中被修改，举例如下:

public void AddValue( MyType typValue )   
{   
　typValue.Count = typValue.Count + 15;   
}  

         由于对于引用类型对象来说，其的赋值操作只是对原有对象的引用，因此在函数对其修改，实际上是直接修改了原有对象数据，这是很多 情况不希望发生的（这里例如对数组或者DataTable操作这类）。

为了防止这种事发生，需要给此类型提供clone函数。例如对 于如上的类型，可以入下实现 :

public class MyType:ICloneable   
{   
　private int nCount = 0;   
　public int Count   
　{   
　　set{ nCount = value;}   
　　get{ return nCount;}   
　}   
　public MyType()   
　{}   
　public MyType( int Value)   
　{   
　　nCount = Value;   
　}   
　#region ICloneable Members   
　public object Clone()   
　{   
　　// TODO: Add MyType.Clone implementation   
　　return new MyType( nCount );   
　}   
  
　#endregion   
}  

　     那么在调用的时候，用当前的对象的clone作为参数即可。

不过对于引用类型来说，提供一个clone函数不是一 件容易的事情，尤其出现引用类型嵌套的时候，所以说去实现一个完全clone功能是件很费事又不讨好的活，这也就是在论坛中常说的深copy和浅copy 的问题。话虽如此，如果对于前面所说的有个大概了解，相信实现也不是不可能。

在C#中，尤其自己定义类型的时候，常常由于是用 struct来定义还是用class来定义，即是定义一个值类型还是一个引用类型呢。在这本书上给了几个判定条件，如果如下几点都满足的话，建议用 struct来定义为值类型，否则用class定义为引用类型。

<!--[if !supportLists]-->1． <!--[endif]-->这个类型是否主要为了数据存储；
<!--[if !supportLists]-->2． <!--[endif]-->是否只通过属性来访问对象的数据成员；
<!--[if !supportLists]-->3． <!--[endif]-->这个类型是否不会有子类型；
<!--[if !supportLists]-->4． <!--[endif]-->在程序处理的时候不会把这个类型对象通过多态来处理。

（1）The Graphics class provides methods for drawing lines, curves, figures, images, and text. A Graphics object stores attributes of the display device and attributes of the items to be drawn.【msdn】

        Graphics是一个device context和你的drawing conetent之间的一个中介。它存储了device context的相关属性，以及drawing content的属性。这样，它就能用自己的方法把drawing content“映射”到device content 之上。

（2）GDI+的核心是Graphics类，包含了显示、绘图等功能。它提供了四个构造函数：
   Graphics::Graphics(Image*)
   Graphics::Graphics(HDC)
   Graphics::Graphics(HDC,HANDLE)
   Graphics::Graphics(HWND,BOOL)

   构造函数1从image对象创建一个Graphics类。这种方式允许你在打开某张，或者生成某张位图之后，应用Grapgics的方法对改位图进行操作。

   构造函数2从一个传统的HDC获取一个Graphics对象，把传统的在HDC完成的操作接手过来。也就是当要画直线，曲线，图形等时，采用这种构造函数。

   后面两种构造函数这里不说了！

（3）如果读者有GDI编程经验的话，应该会联想起CDC::CreateCompatibleDC和CBitmap::
CreateCompatibleBitmap吧？再列举Graphics中有代表性的用于绘图的成员函数：
   Graphics::DrawArc(Pen*,INT,INT,INT,INT,REAL,REAL)
   Graphics::DrawBeziers(Pen*,Point*,INT)
   Graphics::DrawClosedCurve(Pen*,Point*,INT)
   Graphics::DrawCurve(Pen*,Point*,INT)
   Graphics::DrawEllipse(Pen*,Rect&amp;)
   Graphics::DrawImage(Image*,RectF&amp;)
   Graphics::DrawLine(Pen*,Point&amp;,Point&amp;)
   Graphics::DrawPie(Pen*,Rect&amp;,REAL,REAL)
   Graphics::DrawPolygon(Pen*,Point*,INT*)
   Graphics::DrawRectangle(Pen*,Rect&amp;)
   是不是非常象CDC？从这里大家也能猜出一点Graphics类和CDC类的异同吧！简单的说，Graphics的层次更高一些，封装的更好。

2  GDI+的几个特点：

   （1）传统的GDI编程最痛苦的是什么？是不停的CreateObject，SeleteObject，DeleteObject——代码繁琐，一不小心还会内存泄露……现在GDI+结束了这一切，就凭这一个理由，也足够我们转向GDI+了，呵呵。从上面的几个成员函数可以看出来，每个绘图动作都指定了画笔、刷子或者Image，完全抛弃了SelectObject的概念。

   （2）GDI+里面的颜色更加丰富，全面支持32位色，从Color类的构造函数就可以看出来：

           Color::Color(BYTE a, BYTE r, BYTE g, BYTE b);其中a就是透明度。

   （3）GDI+里的所有函数都只接受Unicode字符串，编写代码的时候需要注意这一点。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/keyouan2008/archive/2010/08/13/5809519.aspx

There's a file called /etc/fstab in your Linux system. Learn what its contents mean and how it's used in conjunction with the mount command. When you learn to understand the fstab file, you'll be able to edit its contents yourself, too.

In this tuXfile I assume you already know how to mount filesystems and partitions with the mount command. If you don't, I suggest reading the Mounting tuXfile before reading this one.

Author: Nana Långstedt < nana.langstedt at gmail.com >
tuXfile created: 12 October 2003
Last updated: 5 September 2009

在Fedora core 4.0 加载NTFS和FAT32分区详述

作者：北南南北
来自：LinuxSir.Org
提要：本文主要介绍ntfs文件系统分区及fat32格式分区的挂载方法：简单的说就是让Linux能读取Windows系统下的分区；

++++++++++++++++++++++++++++++++++++
正文：
++++++++++++++++++++++++++++++++++++


一、最基本的几个命令；


1、查看磁盘分区情况的命令fdisk -l ；

比如：

通过上面的我们可以知道 /dev/hda1 是NTFS格式；/dev/hda2是FAT32格式；

2、mount 命令；

就是磁盘分区的挂载命令，如果内核支持的话，mount 命令能挂载几乎所有的文件系统，比如 reiserfs;ext2;ext3;ntfs;fat32;jfs等等；在Linux系统中，我们常用的主要有reiserfs;ext3; ext3；在Windows系统中，我们主要用的是NTFS;FAT32;FAT等；

例子在后面举了，新手弟兄先知道有这回事就行了；

3、df -lh 磁盘使用情况的命令；这个重要吧；

我们在前面已经通过fdisk -l 得知/dev/hda1 是NTFS分区；我们如何加载它呢？在Fedora core 4.0 中，系统默认是不支持NTFS加载的；我们只能安装第三方kernel的ntfs插件或者编内核来实现，相对于编译内核来说，插件是最方便的，也是最简单 的；

我们到哪去下载呢？

kernel ntfs 项目在 http://linux-ntfs.sourceforge.net

Fedora core 4.0的kernel NTFS的RPM包在：

http://linux-ntfs.sourceforge.net/rpm/fedora4.html

根据上面内核的信息，我们要下载：2.6.11-1.1369_FC4 i686的，下载的应该是：

kernel-module-ntfs-2.6.11-1.1369_FC4-2.1.22-0.rr.6.0.i686.rpm

地址： http://prdownloads.sourceforge.net/linux-ntfs/kernel-module-ntfs-2.6.11-1.1369_FC4-2.1.22-0.rr.6.0.i686.rpm

在这里选一个镜像下载：

安装kernel ntfs模块：

我们已经把kernel ntfs的模式安装好了，现在进入NTFS的分区的加载过程；通过上面的查看，我们知道/dev/hda1是NTFS格式的；

1］我们要建一个挂载点的目录，比如是在/mnt/目录下建一个winc的目录：

[root@localhost beinan]# mkdir /mnt/winc

2］把/dev/hda1 挂载到 /mnt/winc中，这样我们如果查看/dev/hda1磁盘内容时，就会在/mnt/winc中找得到；

注：-t ntfs 说明文件系统的格式是ntfs的；-o是选项 ，选项有什么呢？有nls=utf8 ，意思是Native Language Support（本地语言支持）是utf8，也就是大家常说的语言编码；Fedora core 4.0 默认的语言编码就是utf8的，这样能显示出中文来；umask=000表示所有的用户组都可读可写，但因为NTFS在Linux中写入不安全，所以只能 读，不能写入；如果想写入，只能自己编内核来实现；但意义并不是太大；

是不是挂载好了呢？

在GNOME下也是极简单的：

比如我是以beinan这个用户登入的系统，想在放在 beinan 这个用户的GNOME桌面上；

Linux对FAT32的支持是可读可写的，所以没有必要再安装什么模块之类的；

1.我们要建一个挂载点的目录，比如是在/mnt/目录下建一个wind的目录：

在GNOME下也是极简单的：

比如我是以beinan这个用户登入的系统，想在放在 beinan 这个用户的GNOME桌面上；

比如我们看到有些文本文件内容是乱码，我们可以用gedit 打开，然后另存为utf8格式就OK了；

后记：虽然写的详细，但我不敢保证所有初学者都能会操作，但我感觉80%初学者还是按步骤操作不会有问题；

正在修订之中；欢迎提出点意见和建议；谢谢~

1. 初始设置

运行 winecfg，把模拟的 Windows 系统设置为 Windows XP 或者 Windows 2000。

2. 准备字体

为了让 Windows 应用程序看上去更美观，所以需要 Windows 下面的字体。

由于我已经将 simsun.ttc 复制到 /usr/share/fonts/windows/ 目录中了。所以我只需要在 ~/.wine/drive_c/windows/fonts/ 目录中为 simsun.ttc 创建一个符号连接：

cd ~/.wine/drive_c/windows/fonts
ln -s /usr/share/fonts/windows/simsun.ttc simsun.ttc
ln -s /usr/share/fonts/windows/simsun.ttc simfang.ttc

创建一个 simfang.ttc 是许多 Windows 应用默认使用 simfang.ttc 字体。
3. 修改 ~/.wine/system.reg

装好字体后，还要修改一下 Wine 的注册表设置，指定与字体相关的设置：

gedit ~/.wine/system.reg

（一定要使用 gedit 或其他支持 gb2312/utf8 编码的编辑器修改这些文件，否则文件中的中文可能变乱码）

搜索： LogPixels
找到的行应该是：[System\\CurrentControlSet\\Hardware Profiles\\Current\\Software\\Fonts]
将其中的：
"LogPixels"=dword:00000060

改为：
"LogPixels"=dword:00000070

搜索： FontSubstitutes
找到的行应该是：[Software\\Microsoft\\Windows NT\\CurrentVersion\\FontSubstitutes]
将其中的：
"MS Shell Dlg"="Tahoma"
"MS Shell Dlg 2″="Tahoma"

改为：
"MS Shell Dlg"="SimSun"
"MS Shell Dlg 2″="SimSun"

4. 修改 ~/.wine/drive_c/windows/win.ini

gedit ~/.wine/drive_c/windows/win.ini
在文件末尾加入：

[Desktop]
menufontsize=13
messagefontsize=13
statusfontsize=13
IconTitleSize=13

   5. 最关键的一步，网上很多文章中没有提到的一步──把下面的代码保存为zh.reg，然后终端执行regedit zh.reg。从Windows目录下的Fonts里的simsun.ttc复制到/home/user/.wine/drive_c/windows/fonts里面。
      代码:
      REGEDIT4

      [HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\FontSubstitutes]
      "Arial"="simsun"
      "Arial CE,238"="simsun"
      "Arial CYR,204"="simsun"
      "Arial Greek,161"="simsun"
      "Arial TUR,162"="simsun"
      "Courier New"="simsun"
      "Courier New CE,238"="simsun"
      "Courier New CYR,204"="simsun"
      "Courier New Greek,161"="simsun"
      "Courier New TUR,162"="simsun"
      "FixedSys"="simsun"
      "Helv"="simsun"
      "Helvetica"="simsun"
      "MS Sans Serif"="simsun"
      "MS Shell Dlg"="simsun"
      "MS Shell Dlg 2"="simsun"
      "System"="simsun"
      "Tahoma"="simsun"
      "Times"="simsun"
      "Times New Roman CE,238"="simsun"
      "Times New Roman CYR,204"="simsun"
      "Times New Roman Greek,161"="simsun"
      "Times New Roman TUR,162"="simsun"
      "Tms Rmn"="simsun"

之后，中文正常显示哈哈！

  >

QT的信号与槽机制介绍

文档选项 打印本页 将此页作为电子邮件发送 未显示需要 JavaScript 的文档选项 级别： 初级 唐新华 (xhsmart@263.net), 软件工程师 2001 年 6 月 01 日 信号与槽作为QT的核心机制在QT编程中有着广泛的应用，本文介绍了信号与槽的一些基本概念、元对象工具以及在实际使用过程中应注意的一些问题。 QT是一个跨平台的C++ GUI应用构架，它提供了丰富的窗口部件集，具有面向对象、易于扩展、真正的组件编程等特点，更为引人注目的是目前Linux上最为流行的KDE桌面环境就是建立在QT库的基础之上。QT支持下列平台：MS/WINDOWS-95、98、NT和2000；UNIX/X11-Linux、Sun Solaris、HP-UX、Digital Unix、IBM AIX、SGI IRIX；EMBEDDED-支持framebuffer的Linux平台。伴随着KDE的快速发展和普及，QT很可能成为Linux窗口平台上进行软件开发时的GUI首选。 概述 信号和槽机制是QT的核心机制，要精通QT编程就必须对信号和槽有所了解。信号和槽是一种高级接口，应用于对象之间的通信，它是QT的核心特性，也是QT区别于其它工具包的重要地方。信号和槽是QT自行定义的一种通信机制，它独立于标准的C/C++语言，因此要正确的处理信号和槽，必须借助一个称为moc（Meta Object Compiler）的QT工具，该工具是一个C++预处理程序，它为高层次的事件处理自动生成所需要的附加代码。 在我们所熟知的很多GUI工具包中，窗口小部件(widget)都有一个回调函数用于响应它们能触发的每个动作，这个回调函数通常是一个指向某个函数的指针。但是，在QT中信号和槽取代了这些凌乱的函数指针，使得我们编写这些通信程序更为简洁明了。 信号和槽能携带任意数量和任意类型的参数，他们是类型完全安全的，不会像回调函数那样产生core dumps。 所有从QObject或其子类(例如Qwidget)派生的类都能够包含信号和槽。当对象改变其状态时，信号就由该对象发射(emit)出去，这就是对象所要做的全部事情，它不知道另一端是谁在接收这个信号。这就是真正的信息封装，它确保对象被当作一个真正的软件组件来使用。槽用于接收信号，但它们是普通的对象成员函数。一个槽并不知道是否有任何信号与自己相连接。而且，对象并不了解具体的通信机制。 你可以将很多信号与单个的槽进行连接，也可以将单个的信号与很多的槽进行连接，甚至于将一个信号与另外一个信号相连接也是可能的，这时无论第一个信号什么时候发射系统都将立刻发射第二个信号。总之，信号与槽构造了一个强大的部件编程机制。 回页首 信号 当某个信号对其客户或所有者发生的内部状态发生改变，信号被一个对象发射。只有 定义过这个信号的类及其派生类能够发射这个信号。当一个信号被发射时，与其相关联的槽将被立刻执行，就象一个正常的函数调用一样。信号-槽机制完全独立于任何GUI事件循环。只有当所有的槽返回以后发射函数（emit）才返回。 如果存在多个槽与某个信号相关联，那么，当这个信号被发射时，这些槽将会一个接一个地 执行，但是它们执行的顺序将会是随机的、不确定的，我们不能人为地指定哪个先执行、哪 个后执行。 信号的声明是在头文件中进行的，QT的signals关键字指出进入了信号声明区，随后即可 声明自己的信号。例如，下面定义了三个信号： signals: void mySignal(); void mySignal(int x); void mySignalParam(int x,int y); 在上面的定义中，signals是QT的关键字，而非C/C++的。接下来的一行void mySignal() 定义了信号mySignal，这个信号没有携带参数；接下来的一行void mySignal(int x)定义 了重名信号mySignal，但是它携带一个整形参数，这有点类似于C++中的虚函数。从形式上 讲信号的声明与普通的C++函数是一样的，但是信号却没有函数体定义，另外，信号的返回 类型都是void，不要指望能从信号返回什么有用信息。 信号由moc自动产生，它们不应该在.cpp文件中实现。 回页首 槽 槽是普通的C++成员函数，可以被正常调用，它们唯一的特殊性就是很多信号可以与其相关联。当与其关联的信号被发射时，这个槽就会被调用。槽可以有参数，但槽的参数不能有缺省值。 既然槽是普通的成员函数，因此与其它的函数一样，它们也有存取权限。槽的存取权限决定了谁能够与其相关联。同普通的C++成员函数一样，槽函数也分为三种类型，即public slots、private slots和protected slots。 public slots：在这个区内声明的槽意味着任何对象都可将信号与之相连接。这对于组件编程非常有用，你可以创建彼此互不了解的对象，将它们的信号与槽进行连接以便信息能够正确的传递。 protected slots：在这个区内声明的槽意味着当前类及其子类可以将信号与之相连接。这适用于那些槽，它们是类实现的一部分，但是其界面接口却面向外部。 private slots：在这个区内声明的槽意味着只有类自己可以将信号与之相连接。这适用于联系非常紧密的类。 槽也能够声明为虚函数，这也是非常有用的。 槽的声明也是在头文件中进行的。例如，下面声明了三个槽： public slots: void mySlot(); void mySlot(int x); void mySignalParam(int x,int y); 回页首 信号与槽的关联 通过调用QObject对象的connect函数来将某个对象的信号与另外一个对象的槽函数相关联，这样当发射者发射信号时，接收者的槽函数将被调用。该函数的定义如下： bool QObject::connect ( const QObject * sender, const char * signal, const QObject * receiver, const char * member ) [static] 这个函数的作用就是将发射者sender对象中的信号signal与接收者receiver中的member槽函数联系起来。当指定信号signal时必须使用QT的宏SIGNAL()，当指定槽函数时必须使用宏SLOT()。如果发射者与接收者属于同一个对象的话，那么在connect调用中接收者参数可以省略。 例如，下面定义了两个对象：标签对象label和滚动条对象scroll，并将valueChanged()信号与标签对象的setNum()相关联，另外信号还携带了一个整形参数，这样标签总是显示滚动条所处位置的值。 QLabel *label = new QLabel; QScrollBar *scroll = new QScrollBar; QObject::connect( scroll, SIGNAL(valueChanged(int)), label, SLOT(setNum(int)) ); 一个信号甚至能够与另一个信号相关联，看下面的例子： class MyWidget : public QWidget { public: MyWidget(); ... signals: void aSignal(); ... private: ... QPushButton *aButton; }; MyWidget::MyWidget() { aButton = new QPushButton( this ); connect( aButton, SIGNAL(clicked()), SIGNAL(aSignal()) ); } 在上面的构造函数中，MyWidget创建了一个私有的按钮aButton，按钮的单击事件产生的信号clicked()与另外一个信号aSignal()进行了关联。这样一来，当信号clicked()被发射时，信号aSignal()也接着被发射。当然，你也可以直接将单击事件与某个私有的槽函数相关联，然后在槽中发射aSignal()信号，这样的话似乎有点多余。 当信号与槽没有必要继续保持关联时，我们可以使用disconnect函数来断开连接。其定义如下： bool QObject::disconnect ( const QObject * sender, const char * signal, const Object * receiver, const char * member ) [static] 这个函数断开发射者中的信号与接收者中的槽函数之间的关联。 有三种情况必须使用disconnect()函数： 断开与某个对象相关联的任何对象。这似乎有点不可理解，事实上，当我们在某个对象中定义了一个或者多个信号，这些信号与另外若干个对象中的槽相关联，如果我们要切断这些关联的话，就可以利用这个方法，非常之简洁。 disconnect( myObject, 0, 0, 0 ) 或者 myObject->disconnect() 断开与某个特定信号的任何关联。 disconnect( myObject, SIGNAL(mySignal()), 0, 0 ) 或者 myObject->disconnect( SIGNAL(mySignal()) ) 断开两个对象之间的关联。 disconnect( myObject, 0, myReceiver, 0 ) 或者 myObject->disconnect( myReceiver ) 在disconnect函数中0可以用作一个通配符，分别表示任何信号、任何接收对象、接收对象中的任何槽函数。但是发射者sender不能为0，其它三个参数的值可以等于0。 回页首 元对象工具 元对象编译器moc（meta object compiler）对C++文件中的类声明进行分析并产生用于初始化元对象的C++代码，元对象包含全部信号和槽的名字以及指向这些函数的指针。 moc读C++源文件，如果发现有Q_OBJECT宏声明的类，它就会生成另外一个C++源文件，这个新生成的文件中包含有该类的元对象代码。例如，假设我们有一个头文件mysignal.h，在这个文件中包含有信号或槽的声明，那么在编译之前 moc 工具就会根据该文件自动生成一个名为mysignal.moc.h的C++源文件并将其提交给编译器；类似地，对应于mysignal.cpp文件moc工具将自动生成一个名为mysignal.moc.cpp文件提交给编译器。 元对象代码是signal/slot机制所必须的。用moc产生的C++源文件必须与类实现一起进行编译和连接，或者用#include语句将其包含到类的源文件中。moc并不扩展#include或者#define宏定义,它只是简单的跳过所遇到的任何预处理指令。 回页首 程序样例 这里给出了一个简单的样例程序，程序中定义了三个信号、三个槽函数，然后将信号与槽进行了关联，每个槽函数只是简单的弹出一个对话框窗口。读者可以用kdevelop生成一个简单的QT应用程序，然后将下面的代码添加到相应的程序中去。 信号和槽函数的声明一般位于头文件中，同时在类声明的开始位置必须加上Q_OBJECT语句，这条语句是不可缺少的，它将告诉编译器在编译之前必须先应用moc工具进行扩展。关键字signals指出随后开始信号的声明，这里signals用的是复数形式而非单数，siganls没有public、private、protected等属性，这点不同于slots。另外，signals、slots关键字是QT自己定义的，不是C++中的关键字。 信号的声明类似于函数的声明而非变量的声明，左边要有类型，右边要有括号，如果要向槽中传递参数的话，在括号中指定每个形式参数的类型，当然，形式参数的个数可以多于一个。 关键字slots指出随后开始槽的声明，这里slots用的也是复数形式。 槽的声明与普通函数的声明一样，可以携带零或多个形式参数。既然信号的声明类似于普通C++函数的声明，那么，信号也可采用C++中虚函数的形式进行声明，即同名但参数不同。例如，第一次定义的void mySignal()没有带参数，而第二次定义的却带有参数，从这里我们可以看到QT的信号机制是非常灵活的。 信号与槽之间的联系必须事先用connect函数进行指定。如果要断开二者之间的联系，可以使用函数disconnect。 //tsignal.h ... class TsignalApp:public QMainWindow { Q_OBJECT ... //信号声明区 signals: //声明信号mySignal() void mySignal(); //声明信号mySignal(int) void mySignal(int x); //声明信号mySignalParam(int,int) void mySignalParam(int x,int y); //槽声明区 public slots: //声明槽函数mySlot() void mySlot(); //声明槽函数mySlot(int) void mySlot(int x); //声明槽函数mySignalParam (int，int) void mySignalParam(int x,int y); } ... //tsignal.cpp ... TsignalApp::TsignalApp() { ... //将信号mySignal()与槽mySlot()相关联 connect(this,SIGNAL(mySignal()),SLOT(mySlot())); //将信号mySignal(int)与槽mySlot(int)相关联 connect(this,SIGNAL(mySignal(int)),SLOT(mySlot(int))); //将信号mySignalParam(int,int)与槽mySlotParam(int,int)相关联 connect(this,SIGNAL(mySignalParam(int,int)),SLOT(mySlotParam(int,int))); } // 定义槽函数mySlot() void TsignalApp::mySlot() { QMessageBox::about(this,"Tsignal", "This is a signal/slot sample without parameter."); } // 定义槽函数mySlot(int) void TsignalApp::mySlot(int x) { QMessageBox::about(this,"Tsignal", "This is a signal/slot sample with one parameter."); } // 定义槽函数mySlotParam(int,int) void TsignalApp::mySlotParam(int x,int y) { char s[256]; sprintf(s,"x:%d y:%d",x,y); QMessageBox::about(this,"Tsignal", s); } void TsignalApp::slotFileNew() { //发射信号mySignal() emit mySignal(); //发射信号mySignal(int) emit mySignal(5); //发射信号mySignalParam(5，100) emit mySignalParam(5,100); } 回页首 应注意的问题 信号与槽机制是比较灵活的，但有些局限性我们必须了解，这样在实际的使用过程中做到有的放矢，避免产生一些错误。下面就介绍一下这方面的情况。 1．信号与槽的效率是非常高的，但是同真正的回调函数比较起来，由于增加了灵活性，因此在速度上还是有所损失，当然这种损失相对来说是比较小的，通过在一台i586-133的机器上测试是10微秒（运行Linux），可见这种机制所提供的简洁性、灵活性还是值得的。但如果我们要追求高效率的话，比如在实时系统中就要尽可能的少用这种机制。 2．信号与槽机制与普通函数的调用一样，如果使用不当的话，在程序执行时也有可能产生死循环。因此，在定义槽函数时一定要注意避免间接形成无限循环，即在槽中再次发射所接收到的同样信号。例如,在前面给出的例子中如果在mySlot()槽函数中加上语句emit mySignal()即可形成死循环。 3．如果一个信号与多个槽相联系的话，那么，当这个信号被发射时，与之相关的槽被激活的顺序将是随机的。 4. 宏定义不能用在signal和slot的参数中。 既然moc工具不扩展#define，因此，在signals和slots中携带参数的宏就不能正确地工作，如果不带参数是可以的。例如，下面的例子中将带有参数的宏SIGNEDNESS(a)作为信号的参数是不合语法的： #ifdef ultrix #define SIGNEDNESS(a) unsigned a #else #define SIGNEDNESS(a) a #endif class Whatever : public QObject { [...] signals: void someSignal( SIGNEDNESS(a) ); [...] }; 5. 构造函数不能用在signals或者slots声明区域内。 的确，将一个构造函数放在signals或者slots区内有点不可理解，无论如何，不能将它们放在private slots、protected slots或者public slots区内。下面的用法是不合语法要求的： class SomeClass : public QObject { Q_OBJECT public slots: SomeClass( QObject *parent, const char *name ) : QObject( parent, name ) {} // 在槽声明区内声明构造函数不合语法 [...] }; 6. 函数指针不能作为信号或槽的参数。 例如，下面的例子中将void (*applyFunction)(QList*, void*)作为参数是不合语法的： class someClass : public QObject { Q_OBJECT [...] public slots: void apply(void (*applyFunction)(QList*, void*), char*); // 不合语法 }; 你可以采用下面的方法绕过这个限制： typedef void (*ApplyFunctionType)(QList*, void*); class someClass : public QObject { Q_OBJECT [...] public slots: void apply( ApplyFunctionType, char *); }; 7.信号与槽不能有缺省参数。 既然signal->slot绑定是发生在运行时刻，那么，从概念上讲使用缺省参数是困难的。下面的用法是不合理的： class SomeClass : public QObject { Q_OBJECT public slots: void someSlot(int x=100); // 将x的缺省值定义成100，在槽函数声明中使用是错误的 }; 8.信号与槽也不能携带模板类参数。 如果将信号、槽声明为模板类参数的话，即使moc工具不报告错误，也不可能得到预期的结果。 例如，下面的例子中当信号发射时，槽函数不会被正确调用： [...] public slots: void MyWidget::setLocation (pair<int,int> location); [...] public signals: void MyObject::moved (pair<int,int> location); 但是，你可以使用typedef语句来绕过这个限制。如下所示： typedef pair<int,int> IntPair; [...] public slots: void MyWidget::setLocation (IntPair location); [...] public signals: void MyObject::moved (IntPair location); 这样使用的话，你就可以得到正确的结果。 9.嵌套的类不能位于信号或槽区域内，也不能有信号或者槽。 例如，下面的例子中，在class B中声明槽b()是不合语法的，在信号区内声明槽b()也是不合语法的。 class A { Q_OBJECT public: class B { public slots: // 在嵌套类中声明槽不合语法 void b(); [....] }; signals: class B { // 在信号区内声明嵌套类不合语法 void b(); [....] }: }; 10.友元声明不能位于信号或者槽声明区内。 相反，它们应该在普通C++的private、protected或者public区内进行声明。下面的例子是不合语法规范的： class someClass : public QObject { Q_OBJECT [...] signals: //信号定义区 friend class ClassTemplate; // 此处定义不合语法 }; 参考资料 QT KDevelop 关于作者 唐新华 软件工程师。Email: xhsmart@263.net

1. 在出现 lilo: 提示时键入 linux single

Boot: linux single

2. 回车可直接进入linux单用户模式

3. vi /etc/passwd

删除root项中的密码

(这里也可以直接使用passwd命令重新设置root的密码)

4. reboot重启，root密码为空

二. grub引导

1. 在出现grub画面时，选择linux引导项，然后按e键

2. 选择以kernel开头的一行，再按e 键，在此行的末尾，按空格键后输入single，以回车键来退出编辑模式；

3. 回车返回，然后按b键启动，即可直接进入linux单用户模式

4. vi /etc/passwd

删除root项中的密码

(这里也可以直接使用passwd命令重新设置root的密码)

5、reboot重启，root密码为空

三、可以使用linux启动软盘引导

出现boot后，输入linux single

可进入单用户模式；

修改或删除root密码；

四、使用Linux 系统安装盘

如果你既没做系统启动软盘，同时多系统的引导LILO 和GRUB 又被删除，那么只能使用Linux 系统安装盘来恢复root的密码。

用第一张Linux 系统安装盘启动，出现boot 提示符后输入：

oot: linux rescue

此时系统进入救援模式，然后根据提示完成：

1.选择语言和键盘格式；

2.选择是否配置网卡，一般系统因网络不需要，所以可以选择否跳过网卡配置；

3.选择是否让系统查找硬盘上的RedHat Linux 系统，选择继续；

4.系统显示硬盘上的系统已经被找到，并挂载在/mnt/sysimage 下；

5.进入拯救状态，可重新设置root 的密码：

# chroot/mnt/sysimage (让系统成为根环境)

# cd /mnt/sysimage

# passwd root

五、卸下硬盘挂到别的机器上更改

如果不怕麻烦的话，还可以把安装linux的硬盘卸下后挂到其他系统环境下同样是去修改/etc/passwd文件，修改过后保存即可；

注：

1、在不同的linux系统下输入single的方式和方法可能有区别，希望能自己去尝试；

2、除了需要修改/etc/passwd文件外，可能也需要修改/etc/shadow文件，这是/etc/passwd密码文件的投影文件。

一.什么是字节对齐,为什么要对齐?

    现代计算机中内存空间都是按照byte划分的，从理论上讲似乎对任何类型的变量的访问可以从任何地址开始，但实际情况是在访问特定类型变量的时候经常在特 定的内存地址访问，这就需要各种类型数据按照一定的规则在空间上排列，而不是顺序的一个接一个的排放，这就是对齐。
    对齐的作用和原因：各个硬件平台对存储空间的处理上有很大的不同。一些平台对某些特定类型的数据只能从某些特定地址开始存取。比如有些架构的CPU在访问 一个没有进行对齐的变量的时候会发生错误,那么在这种架构下编程必须保证字节对齐.其他平台可能没有这种情况，但是最常见的是如果不按照适合其平台要求对 数据存放进行对齐，会在存取效率上带来损失。比如有些平台每次读都是从偶地址开始，如果一个int型（假设为32位系统）如果存放在偶地址开始的地方，那 么一个读周期就可以读出这32bit，而如果存放在奇地址开始的地方，就需要2个读周期，并对两次读出的结果的高低字节进行拼凑才能得到该32bit数 据。显然在读取效率上下降很多。

二.字节对齐对程序的影响:

    先让我们看几个例子吧(32bit,x86环境,gcc编译器):
设结构体如下定义：
struct A
{
    int a;
    char b;
    short c;
};
struct B
{
    char b;
    int a;
    short c;
};
现在已知32位机器上各种数据类型的长度如下:
char:1(有符号无符号同)    
short:2(有符号无符号同)    
int:4(有符号无符号同)    
long:4(有符号无符号同)    
float:4    double:8
那么上面两个结构大小如何呢?
结果是:
sizeof(strcut A)值为8
sizeof(struct B)的值却是12

结构体A中包含了4字节长度的int一个，1字节长度的char一个和2字节长度的short型数据一个,B也一样;按理说A,B大小应该都是7字节。
之所以出现上面的结果是因为编译器要对数据成员在空间上进行对齐。上面是按照编译器的默认设置进行对齐的结果,那么我们是不是可以改变编译器的这种默认对齐设置呢,当然可以.例如:
#pragma pack (2) /*指定按2字节对齐*/
struct C
{
    char b;
    int a;
    short c;
};
#pragma pack () /*取消指定对齐，恢复缺省对齐*/
sizeof(struct C)值是8。
修改对齐值为1：
#pragma pack (1) /*指定按1字节对齐*/
struct D
{
    char b;
    int a;
    short c;
};
#pragma pack () /*取消指定对齐，恢复缺省对齐*/
sizeof(struct D)值为7。
后面我们再讲解#pragma pack()的作用.

三.编译器是按照什么样的原则进行对齐的?

    先让我们看四个重要的基本概念：
1.数据类型自身的对齐值：
  对于char型数据，其自身对齐值为1，对于short型为2，对于int,float,double类型，其自身对齐值为4，单位字节。
2.结构体或者类的自身对齐值：其成员中自身对齐值最大的那个值。
3.指定对齐值：#pragma pack (value)时的指定对齐值value。
4.数据成员、结构体和类的有效对齐值：自身对齐值和指定对齐值中小的那个值。
有 了这些值，我们就可以很方便的来讨论具体数据结构的成员和其自身的对齐方式。有效对齐值N是最终用来决定数据存放地址方式的值，最重要。有效对齐N，就是 表示“对齐在N上”，也就是说该数据的"存放起始地址%N=0".而数据结构中的数据变量都是按定义的先后顺序来排放的。第一个数据变量的起始地址就是数 据结构的起始地址。结构体的成员变量要对齐排放，结构体本身也要根据自身的有效对齐值圆整(就是结构体成员变量占用总长度需要是对结构体有效对齐值的整数 倍，结合下面例子理解)。这样就不能理解上面的几个例子的值了。
例子分析：
分析例子B；
struct B
{
    char b;
    int a;
    short c;
};
假 设B从地址空间0x0000开始排放。该例子中没有定义指定对齐值，在笔者环境下，该值默认为4。第一个成员变量b的自身对齐值是1，比指定或者默认指定 对齐值4小，所以其有效对齐值为1，所以其存放地址0x0000符合0x0000%1=0.第二个成员变量a，其自身对齐值为4，所以有效对齐值也为4， 所以只能存放在起始地址为0x0004到0x0007这四个连续的字节空间中，复核0x0004%4=0,且紧靠第一个变量。第三个变量c,自身对齐值为 2，所以有效对齐值也是2，可以存放在0x0008到0x0009这两个字节空间中，符合0x0008%2=0。所以从0x0000到0x0009存放的 都是B内容。再看数据结构B的自身对齐值为其变量中最大对齐值(这里是b）所以就是4，所以结构体的有效对齐值也是4。根据结构体圆整的要求， 0x0009到0x0000=10字节，（10＋2）％4＝0。所以0x0000A到0x000B也为结构体B所占用。故B从0x0000到0x000B 共有12个字节,sizeof(struct B)=12;其实如果就这一个就来说它已将满足字节对齐了, 因为它的起始地址是0,因此肯定是对齐的,之所以在后面补充2个字节,是因为编译器为了实现结构数组的存取效率,试想如果我们定义了一个结构B的数组,那 么第一个结构起始地址是0没有问题,但是第二个结构呢?按照数组的定义,数组中所有元素都是紧挨着的,如果我们不把结构的大小补充为4的整数倍,那么下一 个结构的起始地址将是0x0000A,这显然不能满足结构的地址对齐了,因此我们要把结构补充成有效对齐大小的整数倍.其实诸如:对于char型数据，其 自身对齐值为1，对于short型为2，对于int,float,double类型，其自身对齐值为4，这些已有类型的自身对齐值也是基于数组考虑的,只 是因为这些类型的长度已知了,所以他们的自身对齐值也就已知了.
同理,分析上面例子C：
#pragma pack (2) /*指定按2字节对齐*/
struct C
{
    char b;
    int a;
    short c;
};
#pragma pack () /*取消指定对齐，恢复缺省对齐*/
第 一个变量b的自身对齐值为1，指定对齐值为2，所以，其有效对齐值为1，假设C从0x0000开始，那么b存放在0x0000，符合0x0000%1= 0;第二个变量，自身对齐值为4，指定对齐值为2，所以有效对齐值为2，所以顺序存放在0x0002、0x0003、0x0004、0x0005四个连续 字节中，符合0x0002%2=0。第三个变量c的自身对齐值为2，所以有效对齐值为2，顺序存放
在0x0006、0x0007中，符合 0x0006%2=0。所以从0x0000到0x00007共八字节存放的是C的变量。又C的自身对齐值为4，所以C的有效对齐值为2。又8%2=0,C 只占用0x0000到0x0007的八个字节。所以sizeof(struct C)=8.

四.如何修改编译器的默认对齐值?

1.在VC IDE中，可以这样修改：[Project]|[Settings],c/c++选项卡Category的Code Generation选项的Struct Member Alignment中修改，默认是8字节。
2.在编码时，可以这样动态修改：#pragma pack .注意:是pragma而不是progma.

五.针对字节对齐,我们在编程中如何考虑?

    如果在编程的时候要考虑节约空间的话,那么我们只需要假定结构的首地址是0,然后各个变量按照上面的原则进行排列即可,基本的原则就是把结构中的变量按照 类型大小从小到大声明,尽量减少中间的填补空间.还有一种就是为了以空间换取时间的效率,我们显示的进行填补空间进行对齐,比如:有一种使用空间换时间做 法是显式的插入reserved成员：
         struct A{
           char a;
           char reserved[3];//使用空间换时间
           int b;
}

reserved成员对我们的程序没有什么意义,它只是起到填补空间以达到字节对齐的目的,当然即使不加这个成员通常编译器也会给我们自动填补对齐,我们自己加上它只是起到显式的提醒作用.

六.字节对齐可能带来的隐患:

    代码中关于对齐的隐患，很多是隐式的。比如在强制类型转换的时候。例如：
unsigned int i = 0x12345678;
unsigned char *p=NULL;
unsigned short *p1=NULL;

p=&i;
*p=0x00;
p1=(unsigned short *)(p+1);
*p1=0x0000;
最后两句代码，从奇数边界去访问unsignedshort型变量，显然不符合对齐的规定。
在x86上，类似的操作只会影响效率，但是在MIPS或者sparc上，可能就是一个error,因为它们要求必须字节对齐.

七.如何查找与字节对齐方面的问题:

如果出现对齐或者赋值问题首先查看
1. 编译器的big little端设置
2. 看这种体系本身是否支持非对齐访问
3. 如果支持看设置了对齐与否,如果没有则看访问时需要加某些特殊的修饰来标志其特殊访问操作。

八.相关文章:转自http://blog.csdn.net/goodluckyxl/archive/2005/10/17/506827.aspx

 ARM下的对齐处理
from DUI0067D_ADS1_2_CompLib

3.13 type  qulifiers

有部分摘自ARM编译器文档对齐部分

对齐的使用:
1.__align(num)
   这个用于修改最高级别对象的字节边界。在汇编中使用LDRD或者STRD时
   就要用到此命令__align(8)进行修饰限制。来保证数据对象是相应对齐。
   这个修饰对象的命令最大是8个字节限制,可以让2字节的对象进行4字节
   对齐,但是不能让4字节的对象2字节对齐。
   __align是存储类修改,他只修饰最高级类型对象不能用于结构或者函数对象。
  
2.__packed
  __packed是进行一字节对齐
  1.不能对packed的对象进行对齐
  2.所有对象的读写访问都进行非对齐访问
  3.float及包含float的结构联合及未用__packed的对象将不能字节对齐
  4.__packed对局部整形变量无影响
  5.强制由unpacked对象向packed对象转化是未定义,整形指针可以合法定
  义为packed。
     __packed int* p;  //__packed int 则没有意义
  6.对齐或非对齐读写访问带来问题
  __packed struct STRUCT_TEST
 {
  char a;
  int b;
  char c;
 }  ;    //定义如下结构此时b的起始地址一定是不对齐的
         //在栈中访问b可能有问题,因为栈上数据肯定是对齐访问[from CL]
//将下面变量定义成全局静态不在栈上
static char* p;
static struct STRUCT_TEST a;
void Main()
{
 __packed int* q;  //此时定义成__packed来修饰当前q指向为非对齐的数据地址下面的访问则可以

 p = (char*)&a;         
 q = (int*)(p+1);     
 
 *q = 0x87654321;
/*  
得到赋值的汇编指令很清楚
ldr      r5,0x20001590 ; = #0x12345678
[0xe1a00005]   mov      r0,r5
[0xeb0000b0]   bl       __rt_uwrite4  //在此处调用一个写4byte的操作函数
     
[0xe5c10000]   strb     r0,[r1,#0]   //函数进行4次strb操作然后返回保证了数据正确的访问
[0xe1a02420]   mov      r2,r0,lsr #8
[0xe5c12001]   strb     r2,[r1,#1]
[0xe1a02820]   mov      r2,r0,lsr #16
[0xe5c12002]   strb     r2,[r1,#2]
[0xe1a02c20]   mov      r2,r0,lsr #24
[0xe5c12003]   strb     r2,[r1,#3]
[0xe1a0f00e]   mov      pc,r14
*/

/*
如果q没有加__packed修饰则汇编出来指令是这样直接会导致奇地址处访问失败
[0xe59f2018]   ldr      r2,0x20001594 ; = #0x87654321
[0xe5812000]   str      r2,[r1,#0]
*/