发布于：2010-09-20 13:06阅读数：3141

bool IsDirectoryWritable(NSString *dir)
{
    bool result = false;
    
    if(![[NSFileManager defaultManager] fileExistsAtPath:dir])
        return result;
    
    NSString* fileName = [dir stringByAppendingFormat:@"/  _#t.txt"];
    NSData *data = [fileName dataUsingEncoding:NSUTF8StringEncoding];
    [data writeToFile:fileName atomically:NO];
    
    result = [[NSFileManager defaultManager] fileExistsAtPath:fileName];
    if(result)
    {
        [[NSFileManager defaultManager] removeItemAtPath:fileName error:NULL];
    }
    
    return true;
}

这个方法的不好之处就是有可能用于尝试的fileName可能已经存在(虽然已经起的很奇怪了)，这样会导致返回结果不准确，也有可能测试文件创建成功了但是删除却失败了，那么也会导致下次测试不准确,。如果哪位高人有更好的办法，麻烦指教。

[[NSWorkspace sharedWorkspace] openFile:fileName];

[[NSWorkspace sharedWorkspace] selectFile:fileName inFileViewerRootedAtPath:path];  // 如果只打开目录不需要选中具体文件，fileName可为nil。

感谢GZX的投递
今天刚刚收到Windows 8商店的提示，扫雷可以更新了，于是兴致勃勃的下载最新版的Windows 8扫雷，截图给大家看。
从开始屏幕上看，扫雷的应用磁帖并没有发生太大的变化。

UITabBarController是选项卡栏导航控制器，显示效果是在页面底部有多个选项卡，通过点击不同选项卡可以在不同的ViewController之间进行切换。

这种对象的层次结构至少包含6个对象：

一个UITabBarController；

两个UIViewController；

一个UITabBar；

两个UITabBarItem；

UITabBarController 是选项卡栏视图控制器，UITabBar是底部两个UITabBarItem的容器，管理两个UITabBarItem，每个UITabBarItem对 应一个UIViewController，然后每个UIViewController都有自己的视图和视图控制器。

UITabBarController中有一个viewControllers属性，这是一个NSArray，包含选项卡控制器的视图控制器

下面来用代码创建一个UITabBarController：

下面是工程结构：

首先创建两个带xib文件的ViewController，分别为FirstViewController和SecondViewController

然后在AppDelegate.h中声明@property (strong,nonatomic) UITabBarController *tabBarController;，并添加协议UITabBarControllerDelegate

在.m中实现如下代码：

　　Lua 的语法比较简单，学习起来也比较省力，但功能却并不弱。

　　在Lua中，一切都是变量，除了关键字。请记住这句话。

I. 首先是注释

　　写一个程序，总是少不了注释的。
　　在Lua中，你可以使用单行注释和多行注释。
　　单行注释中，连续两个减号"--"表示注释的开始，一直延续到行末为止。相当于C++语言中的"//"。
　　多行注释中，由"--[["表示注释开始，并且一直延续到"]]"为止。这种注释相当于C语言中的"/*…*/"。在注释当中，"[["和"]]"是可以嵌套的。

II. Lua编程

　　经典的"Hello world"的程序总是被用来开始介绍一种语言。在Lua中，写一个这样的程序很简单：
　　print("Hello world")
　　在Lua中，语句之间可以用分号"；"隔开，也可以用空白隔开。一般来说，如果多个语句写在同一行的话，建议总是用分号隔开。
　　Lua 有好几种程序控制语句，如：

　　条件控制：if 条件 then … elseif 条件 then … else … end
　　While循环：while 条件 do … end
　　Repeat循环：repeat … until 条件
　　For循环：for 变量 = 初值，终点值，步进 do … end
　　For循环：for 变量1，变量2，… ，变量N in表或枚举函数 do … end

　　注意一下，for的循环变量总是只作用于for的局部变量，你也可以省略步进值，这时候，for循环会使用1作为步进值。
　　你可以用break来中止一个循环。
　　如果你有程序设计的基础，比如你学过Basic，C之类的，你会觉得Lua也不难。但Lua有几个地方是明显不同于这些程序设计语言的，所以请特别注意。

　　．语句块
　　　　语句块在C++中是用"{"和"}"括起来的，在Lua中，它是用do 和 end 括起来的。比如： 
　　　　do print("Hello") end
　　　　你可以在 函数 中和 语句块 中定局部变量。

　　．赋值语句
　　　　赋值语句在Lua被强化了。它可以同时给多个变量赋值。
　　　　例如：
　　　　a,b,c,d=1,2,3,4
　　　　甚至是：
　　　　a,b=b,a -- 多么方便的交换变量功能啊。
　　　　在默认情况下，变量总是认为是全局的。假如你要定义局部变量，则在第一次赋值的时候，需要用local说明。比如：
　　　　local a,b,c = 1,2,3 -- a,b,c都是局部变量

　　．数值运算
　　　　和C语言一样，支持 +, -, *, /。但Lua还多了一个"^"。这表示指数乘方运算。比如2^3 结果为8, 2^4结果为16。
　　　　连接两个字符串，可以用".."运处符。如：
　　　　"This a " .. "string." -- 等于 "this a string"

　　．比较运算
　　　　< > <= >= == ~=
　　　　分别表示 小于，大于，不大于，不小于，相等，不相等
　　　　所有这些操作符总是返回true或false。
　　　　对于Table，Function和Userdata类型的数据，只有 == 和 ~=可以用。相等表示两个变量引用的是同一个数据。比如：
　　　　a={1,2}
　　　　b=a
　　　　print(a==b, a~=b) -- true, false
　　　　a={1,2}
　　　　b={1,2}
　　　　print(a==b, a~=b) -- false, true

　　．逻辑运算
　　　　and, or, not
　　　　其中，and 和 or 与C语言区别特别大。
　　　　在这里，请先记住，在Lua中，只有false和nil才计算为false，其它任何数据都计算为true，0也是true！
　　　　and 和 or的运算结果不是true和false，而是和它的两个操作数相关。
　　　　a and b：如果a为false，则返回a；否则返回b
　　　　a or b：如果 a 为true，则返回a；否则返回b

　　　　举几个例子：
　　　　 print(4 and 5) --> 5
　　　　 print(nil and 13) --> nil
　　　　 print(false and 13) --> false
　　　　 print(4 or 5) --> 4
　　　　 print(false or 5) --> 5

　　　　在Lua中这是很有用的特性，也是比较令人混洧的特性。
　　　　我们可以模拟C语言中的语句：x = a? b : c，在Lua中，可以写成：x = a and b or c。
　　　　最有用的语句是： x = x or v，它相当于：if not x then x = v end 。

　　．运算符优先级，从高到低顺序如下：
　　　　^
　　　　not - （一元运算）
　　　　 * /
　　　　 + -
　　　　 ..（字符串连接）
　　　　 < > <= >= ~= ==
　　　　 and
　　　　 or

由init、loadView、viewDidLoad、viewDidUnload、dealloc的关系说起

对于iphone开发人员来说，内存管理是极为重要的技巧，哪怕程序的功能再强大，设计再漂亮，如果内存控制不好，也难逃程序莫名退出的噩运，这与网页开发是完全不同的。

内存控制里面有很多门道，在这里分析一下 viewDidUnload 和 dealloc 的区别，关于这两者的区别的文章很多，但是大都是摘抄和翻译官方文档，有的也只是简单的说两句，并没有详细说出两者具体的区别。

在了解两者之间的区别，首先要知道 view 的生命周期，google 里面有很多文章，可以先去搜一下，这里就不详解了。

顾名思义  viewDidUnload 就是当 view 被卸载以后执行的语句，它与 viewDidLoad 是相互呼应的。大家都知道官方的解释是执行类似

self.myOutlet = nil;

的命令，但是为什么这么干，什么时候调用这个方法呢？

这个方法是不能手动调用的，它实际上是当应用程序接收到手机内存警告的时候自动调用的方法，目的就是清空内存除当前 viewController 以外所有已经加载过的 viewController 里面的暂时不再使用的一些控件或数据，以避免应用程序应消耗内存过多被强制关闭。记住，是除当前正在展示的 view 所属 viewController 以外所有已经在内存里面的 viewController 执行 viewDidUnload 方法， 而不是当前 viewController 执行 viewDidUnload，当然，这些 viewController 不会被 dealloc。所以在 viewDidUnload 里面一般都是释放 IBOutlet 变量和在 viewDidLoad、viewWillAppear、viewDidAppear 等方法能够重建的数据。而由其他页面传递过来的数据或者无法经过 viewDidLoad、viewWillAppear、viewDidAppear 等方法重建的数据则不能释放，举例子说如果在 navigationController 由上一个页面传递过来的一张图片，在 viewDidUnload 里被释放的话，则当 view 再次加载的时候就无法恢复了。

那为什么要写成 self.myOutlet = nil; ，实际上这个语法是执行了 property 里的setter 方法，而不是一个简单的变量赋值，它干了两件事：1、老数据 release 掉，2、新数据（nil）retain（当 property 设置为 retain 的情况下），当然对 nil retain 是无意义的。如果写成 myOutlet = nil，那就是简单的把 myOutlet 指向 nil，这样内存就泄漏了，因为老数据没有 release。而如果仅仅写成 [myOutlet release] 也会有问题，因为当 view 被 dealloc 的时候会 再次 release，程序就出错了，而对 nil release 是没有问题的。
 
dealloc 是当前 viewController 被释放的时候，清空所有当前 viewController 里面的实体和数据来释放内存，该方法也是自动调用的，无需手动执行。举例说明当 modalView 被 dismissModalViewControllerAnimated 或者 navigationController 回到上一页的时候，这个方法就会被自动调用。因为这个页面已经不再使用了，所以可以把所有实体和数据都释放（release）掉。

其实两者最大的区别就是： viewDidUnload 是内存除当前以外所有 viewController 同时执行，而 dealloc 只是当前 viewController 执行。这个是网上的材料没有说明的。

个人拙见，不对之处还请提正！

PS: 很多朋友都说无法调试 viewDidUnload，其实是可以的。方法是在 iOS 模拟器的菜单里选 硬件->模拟内存警告，这个时候就可以看到 viewDidUnload 里面 NSLog 的东西了，可以试试在打开过的 viewController 里都 NSLog 一下看看效果。而 dealloc 里面可以直接 NSLog。

由init、loadView、viewDidLoad、viewDidUnload、dealloc的关系说起

init方法

在init方法中实例化必要的对象（遵从LazyLoad思想）

init方法中初始化ViewController本身

 loadView方法

当view需要被展示而它却是nil时，viewController会调用该方法。不要直接调用该方法。

如果手工维护views，必须重载重写该方法

如果使用IB维护views，必须不能重载重写该方法

loadView和IB构建view

你在控制器中实现了loadView方法，那么你可能会在应用运行的某个时候被内存管理控制调用。 如果设备内存不足的时候， view 控制器会收到didReceiveMemoryWarning的消息。 默认的实现是检查当前控制器的view是否在使用。 如果它的view不在当前正在使用的view hierarchy里面，且你的控制器实现了loadView方法，那么这个view将被release, loadView方法将被再次调用来创建一个新的view。

viewDidLoad方法

viewDidLoad 此方法只有当view从nib文件初始化的时候才被调用。

重载重写该方法以进一步定制view

在iPhone OS 3.0及之后的版本中，还应该重载重写viewDidUnload来释放对view的任何索引

viewDidLoad后调用数据Model

viewDidUnload方法

当系统内存吃紧的时候会调用该方法（注：viewController没有被dealloc）

内存吃紧时，在iPhone OS 3.0之前didReceiveMemoryWarning是释放无用内存的唯一方式，但是OS 3.0及以后viewDidUnload方法是更好的方式

在该方法中将所有IBOutlet（无论是property还是实例变量）置为nil（系统release view时已经将其release掉了）

在该方法中释放其他与view有关的对象、其他在运行时创建（但非系统必须）的对象、在viewDidLoad中被创建的对象、缓存数据等 release对象后，将对象置为nil（IBOutlet只需要将其置为nil，系统release view时已经将其release掉了）

一般认为viewDidUnload是viewDidLoad的镜像，因为当view被重新请求时，viewDidLoad还会重新被执行

viewDidUnload中被release的对象必须是很容易被重新创建的对象（比如在viewDidLoad或其他方法中创建的对象），不要release用户数据或其他很难被重新创建的对象

dealloc方法

viewDidUnload和dealloc方法没有关联，dealloc还是继续做它该做的事情

看到以下的代码

- (void)viewDidUnload {

self.detailViewController = nil; 

self.languageNames = nil; 

self.languageCodes = nil;

}

- (void)dealloc {

[detailViewController release];

 [languageNames release]; 

[languageCodes release]; 

[super dealloc];

}

多核运算

在iOS中concurrency编程的框架就是GCD(Grand Central Dispatch)， GCD的使用非常简单。它把任务分派到不同的queue队列来处理。开发者把任务代码装到一个个block里面，操作系统把这些任务代码分派到不同的资源里去处理，一个简单的例子来说，为什么初学者写tableview的时候，滑动列表时总会很卡，因为很多初学者把图片装载放到main thread主线程去执行，例如我们要滑动畅顺的话，iOS最快可以1秒内刷新60次，如何你的一个cell的文字和图片装载超过1/60秒的话，自然就会卡。所以一般我们会把图片装载这些需要多点时间的移出main thread来处理，对于用GCD来说，就是把图片载入放到另外一个queue队列中来异步执行，当资源准备好了后，放回到main thread中显示出来。main thread在GCD中就是main queue。

创建一个新queue队列的代码：

C代码  

1. dispatch_queue_t network_queue;  
2.   
3. network_queue = dispatch_queue_create("com.myapp.network", nill);  

例如，我们图片读取放到network_queue来进行异步执行

C代码  

1. dispatch_async(network_queue, ^{    
2.     UIImage *cellImage = [self loadMyImageFromNetwork:image_url];    
3.     // 将图片cache到本地    
4.     [self cacheImage:cellImage];    
5.     
6.     .....    
7.         
8. } );  

dispatch_async的意思就是将任务进行异步并行处理，不一定需要一个任务处理完后才能处理下一个。以上代码loadMyImageFromNetwork的意思就是从网络中读取图片，这个任务交给network_queue来处理。这样读取图片的时间过长也不会阻塞主线程界面的处理。

当我们处理完图片后，应该更新界面，从queue的概念去设计，就是要将更新界面的代码放到main queue中去，因为iOS里面永远是主线程来刷新重画UI。所以代码应该为，

C代码  

1. dispatch_async(network_queue, ^{    
2.     UIImage *cellImage = [self loadMyImageFromNetwork:image_url];    
3.     // 将图片cache到本地    
4.     [self cacheImage:cellImage];    
5.     
6.    // 回到主线程    
7.    dispatch_async(dispatch_get_main_queue(), ^{    
8.       // 显示图片到界面    
9.       [self displayImageToTableView:cellImage];    
10.    }];    
11.         
12. } );  

dispatch_get_main_queue() 函数就是返回主线程，^{} 封装的就是任务代码，这样嵌套方式就可以从一个队列queue，跳到另一个queue，就是这么简单。

我们一般可以把networking有关的代码放到一个queue，把图片resize的代码放到另外一个queue，处理完后更新界面，只需要嵌套跳回到 main queue。这样加上几行代码，你的程序就可以利用到系统多核资源，把具体的调度工作交给了操作系统自己来分配。有了这样的代码，不管你的硬件是单核，双核还是iMac的4核，甚至8核，都可以非常好地并行处理。

内存管理

我一直惊叹iOS和Objective-C内存处理能力，例如iPad版本的iWork，Pages应用就是一个内存处理技术应用的鬼斧神工之作。想想256M内存的iPad，可以带来如此的华丽的界面同时获得如此流畅的用户体验，真是不简单。原因就是iOS一直提倡开发者在有限硬件资源内写出最优化的代码，使用CPU最少，占用内存最小。

（以下代码适用于iOS SDK 4.1, 由于新SDK 4.2对内存使用有新改动，所以可能有不同。。。）

1. 尽量少的UIView层

通常我们喜欢把很多控件层（UILabel，UIButton，UIView等）一起放到一个大的UIView容器来显示我们的内容，这个方法一般是可以的，但是如果要经常重新刷新内容的大区域界面，多数发生在iPad的应用中，这个方法会带来过多的内存使用和动画的延迟（比较卡），例如，scrollview的动画比较卡，又或者，经常收到内存警告。其中一个重要原因是每个控件，特别是透明底的，会多次重新绘制（drawRect）过多。其解决办法是，尽量将几个控件合并到一个层上来显示，这样系统会减少系统调用drawRect，从而带来性能上的提升。

很简单的一个例子，就是iNotes提供手写功能，用户可以在iPad屏幕上写出不同的笔画，开始的设计是，用户每写一划，iNotes就会生成一个新的透明底UIView来保持这个笔画，用户写了10笔，系统就生产了10个UIView，每个view的大小都是整个屏幕的，以便用户的undo操作。这个方案带来严重的内存问题，因为系统将每个层都保持一个bitmap图，一个像素需要4bit来算，一个层的大小就是 4x1024x768 ~ 3M, 10个层就是 10x3M = 30M，很明显，iPad很快爆出内存警告。

这个例子最后的方案是，所有笔画都画在同一个层，iNotes可以保存笔画的点进行undo操作。这样的方案就是无论用户画多少笔画，界面重画需要的资源都是一样的。

2. 显示最佳尺寸的图片

很多程序员比较懒，网络上拿下来的图片，直接就用UIImageView将其显示给用户，这样的后果就是，程序需要一直保存着大尺寸的图片到内存。解决办法应该是先将图片缩小到需要显示的尺寸，释放大尺寸图片的内存，然后再显示到界面给用户。

3. 尽量使用图片pattern，而不是一张大的图片

例如，很多界面设计者喜欢在界面上放一个大底图，但这个底图是老是占用着内存的，最佳方案是，设计出一个小的pattern图，然后用这个方案显示成底图。

C代码  

1. UIImage *smallImage = [[UIImage alloc] initWithContentsOfFile:path];  
2.   
3. backgroundView.backgroundColor = [UIColor colorWithPatternImage:smallImage];  
4.   
5. [smallImage release];  

4. 使用完资源后，立即释放

一般objective-c的习惯是，用完的资源要立即释放，因为明白什么时候用完某个资源的是程序员你自己。

例如，我们要读较大的图片，把它缩小后，显示到界面去。当大图片使用完成后，应该立即释放。代码如下：

C代码  

1. UIImage *fullscreenImage = [[UIImage alloc] initWithContentOfFile:path];  
2. UIImage *smallImage = [self resizeImage:fullscreenImage];  
3.   
4. [fullscreenImage release];  
5.   
6. imageView.image = smallImage;  
7.   
8. ......  

5. 循环中大量生成的自动释放autorelease对象，可以考虑使用autorelease pool封装

代码范例：

C代码  

1. for(UIView *subview in bigView.subviews) {  
2.     // 使用autorelease pool自动释放对象池  
3.     NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];  
4.   
5.     UIImageView *imageView = (UIImageView *)subview;  
6.       
7.     // subview处理代码  
8.     .......  
9.   
10.     // 销毁自动释放对象  
11.     [pool  drain];  
12. }  

 自动释放对象池把每个循环内生成的临时对象使用完后立即释放

以上的意见是本人多年来编写iPad/iPhone程序的经验，另外iOS4.0的multi-tasking特性发布后，程序可以被调入后台运行，苹果工程师的意见是，进入后台运行时，你的应用应该释放掉能释放的对象，尽量保持在16M左右，这样别的程序运行时才不容易把你的应用挤掉。

--------------------------------------------------

太久没有写东西了，中文写作能力退步了，大家别见怪，多给给意见

Python操作文件和文件夹使用的是os库，下面的代码中主要用到了几个函数：

os.listdir:列出目录下的文件和文件夹

os.path.join:拼接得到一个文件/文件夹的全路径

os.path.isfile:判断是否是文件

os.path.splitext：从名称中取出一个子部分

下面是目录操作的代码

在返回文件的各种信息时，使用自定义类allfile来保存文件的信息，在程序中只用到了文件的全路径，如果需要同时记录文件的大小、时间、类型等信息，可以仿照代码进行扩充。

得到存储文件信息的数组后，还可以将其另存成xml格式，下面是代码，在使用时，需要从Document中导入xml.dom.minidom

下面是保存为xml的代码

执行的代码如下

在Linux命令行状态下，执行Python filesearch.py，便可以生成名为folder.xml的文件。

如果要在Windows中运行该程序，需要把folder变量改成Windows下的格式，例如c:\apache2htdocs，然后执行c:python25python.exe filesearch.py（这里假设python的安装目录是c:python25）

安装时发现没有install过程，直接双击就进入开发环境了。而且装完后没有gcc 等各种编译工具，在TERMINAL下各种命令不识别，想装ruby的各种开发工具，都不行了。

查了半天才发现：

Apple announced Xcode 4.3 for OSX Lion and 4.4 for OSX Mountain Lion last week. The major difference is that Xcode no longer provide an installer which is good thing because you now could update Xcode with AppStore in the future, plus it is much easier to carry the development environment with you. However, there is a little problem with this new version of Xcode, is that all command line toolsets and compilers are not visible in terminal. 

解决方案一：
A simple fix is to update your PATH env:

export PATH=/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin:/Applications/Xcode.app/Contents/Developer/usr/bin:$PATH

Please be noted that clang does not reside in /Developer/usr/bin, it is now in /Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin

Now you could access to gcc, g++, git or any toolsets bundled with Xcode. For your convenience, it is recommended to include it in your .bash_profile.

解决方案二：

You can install these additional tools directly in Xcode :
Preferences > Downloads > Command Line Tools > Install

SO. What a fUUUcking day！

请说出const与#define 相比，有何优点？
答案：1） const 常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会产生意料不到的错误。
      2） 有些集成化的调试工具可以对const 常量进行调试，但是不能对宏常量进行调试。

在8086 汇编下，逻辑地址和物理地址是怎样转换的？（Intel）
答案：通用寄存器给出的地址，是段内偏移地址，相应段寄存器地址*10H+通用寄存器内地址，就得到了真正要访问的地址。

当一个类A 中没有生命任何成员变量与成员函数,这时sizeof(A)的值是多少，如果不是零，请解释一下编译器为什么没有让它为零。（Autodesk）
答案：肯定不是零。举个反例，如果是零的话，声明一个class A[10]对象数组，而每一个对象占用的空间是零，这时就没办法区分A[0],A[1]…了。

 描述内存分配方式以及它们的区别?
1） 从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static 变量。
2） 在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集。
3） 从堆上分配，亦称动态内存分配。程序在运行的时候用malloc 或new 申请任意多少的内存，程序员自己负责在何时用free 或delete 释放内存。动态内存的生存期由程序员决定，使用非常灵活，但问题也最多。

 main 函数执行以前，还会执行什么代码？
答案：全局对象的构造函数会在main 函数之前执行。

 C++是不是类型安全的？
答案：不是。两个不同类型的指针之间可以强制转换（用reinterpret cast)。C#是类型安全的。

有哪几种情况只能用intialization list 而不能用assignment?

答案：当类中含有const、reference 成员变量；基类的构造函数都需要初始化表。

define DOUBLE(x) x+x ，i = 5*DOUBLE(5)； i 是多少？
答案：i 为30

New delete 与malloc free 的联系与区别?
答案：都是在堆(heap)上进行动态的内存操作。用malloc函数需要指定内存分配的字节数并且不能初始化对象，new 会自动调用对象的构造函数。delete 会调用对象的destructor，而free 不会调用对象的destructor.

1、写一个“标准”宏，这个宏输入两个参数并返回较小的一个。
.#define Min(X, Y) ((X)>(Y)?(Y):(X))//结尾没有;
2、嵌入式系统中经常要用到无限循环，你怎么用C编写死循环。
while(1){}或者for(;;)
3、关键字static的作用是什么？
定义静态变量
4、关键字const有什么含意？
表示常量不可以修改的变量。
5、关键字volatile有什么含意？并举出三个不同的例子？
提示编译器对象的值可能在编译器未监测到的情况下改变。

int (*s[10])(int) 表示的是什么啊
int (*s[10])(int) 函数指针数组，每个指针指向一个int func(int param)的函数。

1.有以下表达式：
int a=248; b=4;int const c=21;const int *d=&a;
int *const e=&b;int const *f const =&a;
请问下列表达式哪些会被编译器禁止？为什么？
*c=32;d=&b;*d=43;e=34;e=&a;f=0x321f;
*c 这是个什么东东，禁止
*d 说了是const， 禁止
e = &a 说了是const 禁止
const *f const =&a; 禁止
2.交换两个变量的值，不使用第三个变量。即a=3,b=5,交换之后a=5,b=3;
有两种解法, 一种用算术算法, 一种用^(异或)
a = a + b;
b = a - b;
a = a - b; 
or
a = a^b;// 只能对int,char..
b = a^b;
a = a^b;
or
a ^= b ^= a;
3.c和c++中的struct有什么不同？
c和c++中struct的主要区别是c中的struct不可以含有成员函数，而c++中的struct可以。c++中struct和class的主要区别在于默认的存取权限不同，struct默认为public，而class默认为private
4.＃i nclude <stdio.h>
＃i nclude <stdlib.h>
void getmemory(char *p)
{
    p=(char *) malloc(100);
    strcpy(p,"hello world");
}
int main( )
{
    char *str=NULL;
    getmemory(str);
    printf("%s/n",str);
    free(str);
    return 0;
   }
程序崩溃，getmemory中的malloc 不能返回动态内存， free（）对str操作很危险
5.char szstr[10];
strcpy(szstr,"0123456789");
产生什么结果？为什么？
长度不一样，会造成非法的OS
6.列举几种进程的同步机制，并比较其优缺点。
   原子操作 
信号量机制
   自旋锁
   管程，会合，分布式系统

7.进程之间通信的途径
共享存储系统
消息传递系统
管道：以文件系统为基础
11.进程死锁的原因
资源竞争及进程推进顺序非法
12.死锁的4个必要条件
互斥、请求保持、不可剥夺、环路
13.死锁的处理
鸵鸟策略、预防策略、避免策略、检测与解除死锁
15.   操作系统中进程调度策略有哪几种？
FCFS(先来先服务)，优先级，时间片轮转，多级反馈
8.类的静态成员和非静态成员有何区别？
类的静态成员每个类只有一个，非静态成员每个对象一个
9.纯虚函数如何定义？使用时应注意什么？
virtual void f()=0;
是接口，子类必须要实现
10.数组和链表的区别
数组：数据顺序存储，固定大小
连表：数据可以随机存储，大小可动态改变

12.ISO的七层模型是什么？tcp/udp是属于哪一层？tcp/udp有何优缺点？
应用层
表示层
会话层
运输层
网络层
物理链路层
物理层
tcp /udp属于运输层
TCP 服务提供了数据流传输、可靠性、有效流控制、全双工操作和多路复用技术等。
与 TCP 不同， UDP 并不提供对 IP 协议的可靠机制、流控制以及错误恢复功能等。由于 UDP 比较简单， UDP 头包含很少的字节，比 TCP 负载消耗少。
tcp: 提供稳定的传输服务，有流量控制，缺点是包头大，冗余性不好
udp: 不提供稳定的服务，包头小，开销小  

1：(void *)ptr 和 (*(void**))ptr的结果是否相同？其中ptr为同一个指针
.(void *)ptr 和 (*(void**))ptr值是相同的
2：int main()
   {
    int x=3;
    printf("%d",x);
    return 1;
   
   }
问函数既然不会被其它函数调用，为什么要返回1？
mian中，c标准认为0表示成功，非0表示错误。具体的值是某中具体出错信息

1，要对绝对地址0x100000赋值，我们可以用
(unsigned int*)0x100000 = 1234;
那么要是想让程序跳转到绝对地址是0x100000去执行，应该怎么做？
*((void (*)( ))0x100000 ) ( );
首先要将0x100000强制转换成函数指针,即:
(void (*)())0x100000
然后再调用它:
*((void (*)())0x100000)();
用typedef可以看得更直观些:
typedef void(*)() voidFuncPtr;
*((voidFuncPtr)0x100000)();
2，已知一个数组table，用一个宏定义，求出数据的元素个数
#define NTBL
#define NTBL (sizeof(table)/sizeof(table[0]))

面试题: 线程与进程的区别和联系? 线程是否具有相同的堆栈? dll是否有独立的堆栈?
进程是死的，只是一些资源的集合，真正的程序执行都是线程来完成的，程序启动的时候操作系统就帮你创建了一个主线程。

每个线程有自己的堆栈。
DLL中有没有独立的堆栈，这个问题不好回答，或者说这个问题本身是否有问题。因为DLL中的代码是被某些线程所执行，只有线程拥有堆栈，如果DLL中的代码是EXE中的线程所调用，那么这个时候是不是说这个DLL没有自己独立的堆栈？如果DLL中的代码是由DLL自己创建的线程所执行，那么是不是说DLL有独立的堆栈？

以上讲的是堆栈，如果对于堆来说，每个DLL有自己的堆，所以如果是从DLL中动态分配的内存，最好是从DLL中删除，如果你从DLL中分配内存，然后在EXE中，或者另外一个DLL中删除，很有可能导致程序崩溃

unsigned short A = 10;
printf("~A = %u\n", ~A);

char c=128; 
printf("c=%d\n",c);

输出多少？并分析过程
第一题，～A ＝0xfffffff5,int值 为－11，但输出的是uint。所以输出4294967285
第二题，c＝0x10,输出的是int，最高位为1，是负数，所以它的值就是0x00的补码就是128，所以输出－128。
这两道题都是在考察二进制向int或uint转换时的最高位处理。

分析下面的程序：
void GetMemory(char **p,int num)
{
    *p=(char *)malloc(num);
    
}        
int main()
{
    char *str=NULL;
    
    GetMemory(&str,100);
    
    strcpy(str,"hello");
    
    free(str);
    
    if(str!=NULL)
    {
        strcpy(str,"world");
    }    
        
    printf("\n str is %s",str);
    getchar();
}    
问输出结果是什么？希望大家能说说原因，先谢谢了
输出str is world。
free 只是释放的str指向的内存空间,它本身的值还是存在的.
所以free之后，有一个好的习惯就是将str=NULL.
此时str指向空间的内存已被回收,如果输出语句之前还存在分配空间的操作的话,这段存储空间是可能被重新分配给其他变量的,
尽管这段程序确实是存在大大的问题（上面各位已经说得很清楚了），但是通常会打印出world来。
这是因为，进程中的内存管理一般不是由操作系统完成的，而是由库函数自己完成的。
当你malloc一块内存的时候，管理库向操作系统申请一块空间（可能会比你申请的大一些），然后在这块空间中记录一些管理信息（一般是在你申请的内存前面一点），并将可用内存的地址返回。但是释放内存的时候，管理库通常都不会将内存还给操作系统，因此你是可以继续访问这块地址的，只不过。。。。。。。。楼上都说过了，最好别这么干。

char a[10],strlen(a)为什么等于15？运行的结果

＃i nclude "stdio.h"
＃i nclude "string.h"

void main()
{

char aa[10];
printf("%d",strlen(aa));
}

sizeof()和初不初始化，没有关系；
strlen()和初始化有关。

char (*str)[20];/*str是一个数组指针，即指向数组的指针．*/
char *str[20];/*str是一个指针数组，其元素为指针型数据．*/

long a=0x801010;
a+5=?
0x801010用二进制表示为：“1000 0000 0001 0000 0001 0000”，十进制的值为8392720，再加上5就是8392725罗

1)给定结构struct A 
{
       char t:4;
       char k:4;
       unsigned short i:8;
       unsigned long m;
};问sizeof(A) = ?
给定结构struct A 
{
       char t:4; 4位
       char k:4; 4位
       unsigned short i:8; 8位      
       unsigned long m; // 偏移2字节保证4字节对齐
}; // 共8字节
2)下面的函数实现在一个数上加一个数，有什么错误？请改正。
int add_n ( int n )
{
    static int i = 100;
    i += n;
    return i;
}
当你第二次调用时得不到正确的结果，难道你写个函数就是为了调用一次？问题就出在 static上？

// 帮忙分析一下
＃i nclude<iostream.h>
＃i nclude <string.h>
＃i nclude <malloc.h>
＃i nclude <stdio.h>
＃i nclude <stdlib.h>
＃i nclude <memory.h>
typedef struct AA
{
        int b1:5;
        int b2:2;
}AA;
void main()
{
        AA aa;
        char cc[100];
         strcpy(cc,"0123456789abcdefghijklmnopqrstuvwxyz");
       memcpy(&aa,cc,sizeof(AA));
        cout << aa.b1 <<endl;
        cout << aa.b2 <<endl;
}
答案是 -16和１
首先sizeof(AA)的大小为4,b1和b2分别占5bit和2bit.
经过strcpy和memcpy后,aa的4个字节所存放的值是:
0,1,2,3的ASC码，即00110000,00110001,00110010,00110011
所以，最后一步：显示的是这４个字节的前５位，和之后的２位
分别为：10000,和01
因为int是有正负之分　　所以：答案是-16和１

求函数返回值，输入x=9999; 
int func （ x ）
{ 
    int countx = 0; 
    while ( x ) 
    { 
        countx ++; 
        x = x&(x-1); 
    } 
    return countx; 
} 
结果呢？
知道了这是统计9999的二进制数值中有多少个1的函数，且有
9999＝9×1024＋512＋256＋15

9×1024中含有1的个数为2；
512中含有1的个数为1；
256中含有1的个数为1；
15中含有1的个数为4；
故共有1的个数为8，结果为8。
1000 - 1 = 0111，正好是原数取反。这就是原理。
用这种方法来求1的个数是很效率很高的。
不必去一个一个地移位。循环次数最少。

int a,b,c 请写函数实现C=a+b ,不可以改变数据类型,如将c改为long int,关键是如何处理溢出问题
bool add (int a, int b,int *c)
{
*c=a+b;
return (a>0 && b>0 &&(*c<a || *c<b) || (a<0 && b<0 &&(*c>a || *c>b)));
}

分析：
struct bit 
{   int a:3; 
    int b:2; 
    int c:3; 
}; 
int main() 
{ 
bit s; 
char *c=(char*)&s; 
   cout<<sizeof(bit)<<endl;
*c=0x99;
   cout << s.a <<endl <<s.b<<endl<<s.c<<endl; 
     int a=-1;
   printf("%x",a);
return 0; 
} 
输出为什么是
4
1
-1
-4
ffffffff
因为0x99在内存中表示为 100 11 001 , a = 001, b = 11, c = 100
当c为有符合数时, c = 100, 最高1为表示c为负数，负数在计算机用补码表示，所以c = -4;同理 
b = -1;
当c为有符合数时, c = 100,即 c = 4,同理 b = 3

位域 ：   
有些信息在存储时，并不需要占用一个完整的字节， 而只需占几个或一个二进制位。例如在存放一个开关量时，只有0和1 两种状态， 用一位二进位即可。为了节省存储空间，并使处理简便，Ｃ语言又提供了一种数据结构，称为“位域”或“位段”。所谓“位域”是把一个字节中的二进位划分为几个不同的区域， 并说明每个区域的位数。每个域有一个域名，允许在程序中按域名进行操作。 这样就可以把几个不同的对象用一个字节的二进制位域来表示。一、位域的定义和位域变量的说明位域定义与结构定义相仿，其形式为：     
struct 位域结构名     
{ 位域列表 };    
其中位域列表的形式为： 类型说明符 位域名：位域长度     
例如：     
struct bs    
{    
int a:8;    
int b:2;    
int c:6;    
};    
位域变量的说明与结构变量说明的方式相同。 可采用先定义后说明，同时定义说明或者直接说明这三种方式。例如：     
struct bs    
{    
int a:8;    
int b:2;    
int c:6;    
}data;    
说明data为bs变量，共占两个字节。其中位域a占8位，位域b占2位，位域c占6位。对于位域的定义尚有以下几点说明：   

1. 一个位域必须存储在同一个字节中，不能跨两个字节。如一个字节所剩空间不够存放另一位域时，应从下一单元起存放该位域。也可以有意使某位域从下一单元开始。例如：     
struct bs    
{    
unsigned a:4    
unsigned :0 /*空域*/    
unsigned b:4 /*从下一单元开始存放*/    
unsigned c:4    
}    
在这个位域定义中，a占第一字节的4位，后4位填0表示不使用，b从第二字节开始，占用4位，c占用4位。   

2. 由于位域不允许跨两个字节，因此位域的长度不能大于一个字节的长度，也就是说不能超过8位二进位。   

3. 位域可以无位域名，这时它只用来作填充或调整位置。无名的位域是不能使用的。例如：     
struct k    
{    
int a:1    
int :2 /*该2位不能使用*/    
int b:3    
int c:2    
};    
从以上分析可以看出，位域在本质上就是一种结构类型， 不过其成员是按二进位分配的。   

二、位域的使用位域的使用和结构成员的使用相同，其一般形式为： 位域变量名•位域名 位域允许用各种格式输出。    
main(){    
struct bs    
{    
unsigned a:1;    
unsigned b:3;    
unsigned c:4;    
} bit,*pbit;    
bit.a=1;    
bit.b=7;    
bit.c=15;    
pri

改错：
＃i nclude <stdio.h>

int main(void) {

    int **p;
    int arr[100];

    p = &arr;

    return 0;
}
解答：
搞错了,是指针类型不同,
int **p; //二级指针
&arr; //得到的是指向第一维为100的数组的指针
＃i nclude <stdio.h>
int main(void) {
int **p, *q;
int arr[100];
q = arr;
p = &q;
return 0;
}

下面这个程序执行后会有什么错误或者效果:
#define MAX 255
int main()
{
   unsigned char A[MAX],i;//i被定义为unsigned char
   for (i=0;i<=MAX;i++)
      A[i]=i;
}
解答：死循环加数组越界访问（C/C++不进行数组越界检查）
MAX=255 
数组A的下标范围为:0..MAX-1,这是其一..
其二.当i循环到255时,循环内执行:
A[255]=255;
这句本身没有问题..但是返回for (i=0;i<=MAX;i++)语句时,
由于unsigned char的取值范围在(0..255),i++以后i又为0了..无限循环下去.

struct name1{
   char str;
   short x;
   int   num;
}

struct name2{
   char str;
   int num;
   short x;
}

sizeof(struct name1)=8,sizeof(struct name2)=12
在第二个结构中，为保证num按四个字节对齐，char后必须留出3字节的空间；同时为保证整个结构的自然对齐（这里是4字节对齐），在x后还要补齐2个字节，这样就是12字节。

intel：
A.c 和B.c两个c文件中使用了两个相同名字的static变量,编译的时候会不会有问题?这两个static变量会保存到哪里（栈还是堆或者其他的）?
static的全局变量，表明这个变量仅在本模块中有意义，不会影响其他模块。
他们都放在数据区，但是编译器对他们的命名是不同的。
如果要使变量在其他模块也有意义的话，需要使用extern关键字。

struct s1
{
int i: 8;
int j: 4;
int a: 3;
double b;
};

struct s2
{
int i: 8;
int j: 4;
double b;
int a:3;
};

printf("sizeof(s1)= %d\n", sizeof(s1));
printf("sizeof(s2)= %d\n", sizeof(s2));
result: 16, 24
第一个struct s1
{
int i: 8;
int j: 4;
int a: 3;
double b;
};
理论上是这样的，首先是i在相对0的位置，占8位一个字节，然后，j就在相对一个字节的位置，由于一个位置的字节数是4位的倍数，因此不用对齐，就放在那里了，然后是a，要在3位的倍数关系的位置上，因此要移一位，在15位的位置上放下，目前总共是18位，折算过来是2字节2位的样子，由于double是8字节的，因此要在相对0要是8个字节的位置上放下，因此从18位开始到8个字节之间的位置被忽略，直接放在8字节的位置了，因此，总共是16字节。

第二个最后会对照是不是结构体内最大数据的倍数，不是的话，会补成是最大数据的倍数

上面是基本问题，接下来是编程问题：

本人很弱，这几个题也搞不定，特来求救：
1）读文件file1.txt的内容（例如）：
12
34
56
输出到file2.txt：
56
34
12
（逆序）
2）输出和为一个给定整数的所有组合
例如n=5
5=1+4；5=2+3（相加的数不能重复）
则输出
1，4；2，3。
望高手赐教！！

第一题,注意可增长数组的应用.
＃i nclude <stdio.h>
＃i nclude <stdlib.h>

int main(void)
{
         int MAX = 10;
int *a = (int *)malloc(MAX * sizeof(int));
int *b;
    
FILE *fp1;
FILE *fp2;

fp1 = fopen("a.txt","r");
if(fp1 == NULL)
{printf("error1");
    exit(-1);
}

    fp2 = fopen("b.txt","w");
if(fp2 == NULL)
{printf("error2");
    exit(-1);
}

int i = 0;
    int j = 0;

while(fscanf(fp1,"%d",&a[i]) != EOF)
{
i++;
j++;
if(i >= MAX)
{
MAX = 2 * MAX;
b = (int*)realloc(a,MAX * sizeof(int));
if(b == NULL)
{
printf("error3");
exit(-1);
}
a = b;
}
}

for(;--j >= 0;)
   fprintf(fp2,"%d\n",a[j]);

fclose(fp1);
fclose(fp2);

return 0;
}

第二题.
＃i nclude <stdio.h>

int main(void)
{
unsigned long int i,j,k;

printf("please input the number\n");
scanf("%d",&i);
    if( i % 2 == 0)
        j = i / 2;
else
j = i / 2 + 1;

printf("The result is \n");
    for(k = 0; k < j; k++)
     printf("%d = %d + %d\n",i,k,i - k);
return 0;
}

＃i nclude <stdio.h>
void main()
{
unsigned long int a,i=1;
scanf("%d",&a);
if(a%2==0)
{
     for(i=1;i<a/2;i++)
     printf("%d",a,a-i);
}
else
for(i=1;i<=a/2;i++)
        printf(" %d, %d",i,a-i);
}

兄弟,这样的题目若是做不出来实在是有些不应该, 给你一个递规反向输出字符串的例子,可谓是反序的经典例程.

void inverse(char *p)
{
    if( *p = = '\0' ) 
return;
    inverse( p+1 );
    printf( "%c", *p );
}

int main(int argc, char *argv[])
{
    inverse("abc\0");

    return 0;
}

借签了楼上的“递规反向输出”
＃i nclude <stdio.h>
void test(FILE *fread, FILE *fwrite)
{
        char buf[1024] = {0};
        if (!fgets(buf, sizeof(buf), fread))
}

Ubuntu Mobile Phone Concepts

Ubuntu’s plan for a multi-device presence, to potentially include smartphones, has fired up the imagination of users.

And the community have been quick to stoke their creative talents in mocking up a variety of possible implementations.

Below are three of those community designs that have landed in our inbox over the last week…

Community Designs

Nick Rutledge mailed in with a link to his initial designs which are more traditional in approach than some mobile mock-ups that have been bandied around.

nrutledge.blogspot.com/p/ubuntu-mobile-project.html

Sam Horne’s mock-ups are ‘Unity-esque’ in appearance, with a strong emphasis given to familiar Unity elements such as the launcher and a ‘Dash’ style search – both of which are played to great use on his home-screen design in particular.

“I would like to share with you my own Ubuntu for mobile phones mock-up, just as a way of giving my two cents.” Sam told us when mailing in his designs.

“I gave the design some real thought (even if it’s not a perfect mock-up) to truly show how I’d make the mobile OS. Getting the design right is a big deal in my head, so I used my own HTC Desire to look at  them every time I made a change, just to make sure it felt natural or doable on an actual smartphone.”

ginjaninja405.deviantart.com/art/Ubuntu-with-mobile-Unity-268863703

Serial designer Musl1m took to his DeviantArt with a well thought out, and very Faenza styled, design.

I love the approach to app navigation, particularly in his ‘Ubuntu Software Centre’ design.

musl1m.deviantart.com/art/Ubuntu-Phone-Explained-271229476

RedCrab Calculator 是由德国人开发的科学计算器。它除了命令行功能，还带有一个图形化的全屏公式编辑器，只需用鼠标绘制几何图形、微积分、电路图等等，它就会自动计算出结果。甚至还可以显示分步求解过程，可以提高广大同学们的工作效率。

http://www.redchillicrab.com/en/redcrab/index.html

RedCrab Version 3.50.31 History - what's new ? Awards Screen Shots Tutor / Videos User Manual (pdf) . Download RedCrab

RedCrab - The Calculator RedCrab is a scientific calculator with a full screen formula editor. The mathematical expressions are not typed in a typical command line, but can be enter in an editor window similar to a piece of paper.  The calculator's editor supports the entry of complex algebraic equations like fractions, square roots, exponents, etc. for technical and scientific applications. No installation of the software is required. You can just copy the software to your system and starts the program. Starts from external disk, for example USB flash drive or CD / DVD Why RedCrab? No one today would want to work with word processing program that simulates a typewriter, for example, no copy, paste and edit. For typo errors, whole text must be rewritten. But most PC calculators are just unflexible simulations of pocket calculators. RedCrab is a calculator that exploits the possibilities of PC's. Easy to use like a pocket calculator, but provided with full screen editor, which supported corrections, saveing and printing as a word processing program. Several tasks can be written in the same worksheet. Results can be adopted in other mathematical problems as in a spreadsheet program. Images and texts can imported to describe complex calculations. Quick start without studying the manual The handling of the basic functions is just like a conventional calculator. There is no training required. Whoever can operate a pocket calculator can also use RedCrab without studying the manual. This guide describes fundamentally the advanced features which a normal calculator does not possess. RedCrab is portable RedCrab is fully portable. The program can be started from external data storage source without installation. Settings can be stored as a file in the prorams root directory instead in the PC' s Windows registry.  If you start RedCrab from a USB flash drive, your settings are stored on the stick.   System requirement Minimum Pentium P4 and 500MB RAM. Operating system: Microsoft *Windows  Operating system: Linux with Wine runtime system What others think about RedCrab: itreadme.com : Red Crab’s Advantages over Windows Calculator mydigitallife.info: Scientific Calculator For Complex Calculations downloadcrew.com:Solve complex equations in seconds with this powerful calculator tricks-collections.com: Free and Portable Scientific Calculator

*Windows is a registered trademark of Microsoft Corporation.

简介： Google 提供一种用于为 C/C++ 软件开发单元测试的开放源码框架，它很有意思，也很容易使用。本文介绍一些比较有用的 Google C++ Testing Framework 特性。本文基于 version 1.4。

为什么要使用 Google C++ Testing Framework？

使用这个框架有许多好理由。本节讨论其中几个。

某些类型的测试有糟糕的内存问题，这些问题只在某几次运行期间出现。Google 的测试框架为处理这种情况提供了出色的支持。可以使用 Google 框架重复运行相同的测试一千次。当出现故障的迹象时，自动地调用调试器。另外，这只需要在命令行上传递两个开关即可实现：--gtest_repeat=1000 --gtest_break_on_failure。

与其他许多测试框架相反，可以把 Google 测试框架内置的断言部署在禁用了异常处理（通常由于性能原因）的软件中。因此，也可以在析构函数中安全地使用断言。

运行测试很简单。只需调用预定义的 RUN_ALL_TESTS 宏，而不需要通过创建或驱动单独的运行器类来执行测试。这比 CppUnit 等框架方便多了。

只需传递一个开关即可生成 Extensible Markup Language (XML) 报告： --gtest_output="xml:<file name>"。在 CppUnit 和 CppTest 等框架中，需要编写很多代码才能生成 XML 输出。

创建基本测试

请考虑 清单 1 所示的平方根函数的原型。

清单 1. 平方根函数的原型

double square-root (const double);

对于负数，这个例程返回 -1。正数测试和负数测试对它都有意义，所以我们编写两个测试。清单 2 给出测试用例。

清单 2. 平方根函数的单元测试

#include "gtest/gtest.h"

TEST (SquareRootTest, PositiveNos) {

EXPECT_EQ (18.0, square-root (324.0));

EXPECT_EQ (25.4, square-root (645.16));

EXPECT_EQ (50.3321, square-root (2533.310224));

}

TEST (SquareRootTest, ZeroAndNegativeNos) {

ASSERT_EQ (0.0, square-root (0.0));

ASSERT_EQ (-1, square-root (-22.0));

}

清单 2 创建一个名为 SquareRootTest 的测试层次结构，然后在其中添加两个单元测试 PositiveNos 和 ZeroAndNegativeNos。TEST 是在 gtest.h（可以在下载的源代码中找到）中定义的预定义宏，它帮助定义这个层次结构。EXPECT_EQ 和 ASSERT_EQ 也是宏 — 对于前者，即使出现测试失败，测试仍然继续执行；对于后者，测试终止执行。显然，如果 0 的平方根是除 0 之外的任何数字，就没必要再执行测试了。因此，ZeroAndNegativeNos 测试只使用 ASSERT_EQ，而 PositiveNos 测试使用 EXPECT_EQ，来报告存在多少个测试用例是平方根函数失败而不终止测试的情况。

运行第一个测试

既然已经创建了第一个基本测试，现在就该运行它了。清单 3 是运行测试的主例程。

清单 3. 运行平方根测试

#include "gtest/gtest.h"

TEST(SquareRootTest, PositiveNos) {

EXPECT_EQ (18.0, square-root (324.0));

EXPECT_EQ (25.4, square-root (645.16));

EXPECT_EQ (50.3321, square-root (2533.310224));

}

TEST (SquareRootTest, ZeroAndNegativeNos) {

ASSERT_EQ (0.0, square-root (0.0));

ASSERT_EQ (-1, square-root (-22.0));

}

int main(int argc, char **argv) {

::testing::InitGoogleTest(&argc, argv);

return RUN_ALL_TESTS();

}

顾名思义，::testing::InitGoogleTest 方法的作用就是对框架进行初始化，必须在调用 RUN_ALL_TESTS 之前调用它。在代码中只能调用 RUN_ALL_TESTS 一次，因为多次调用会与框架的一些高级特性冲突，不支持这种做法。注意，RUN_ALL_TESTS 自动地探测并运行用 TEST 宏定义的所有测试。在默认情况下，结果输出到标准输出。清单 4 给出输出。

清单 4. 运行平方根测试的输出

Running main() from user_main.cpp

[==========] Running 2 tests from 1 test case.

[----------] Global test environment set-up.

[----------] 2 tests from SquareRootTest

[ RUN ] SquareRootTest.PositiveNos

..\user_sqrt.cpp(6862): error: Value of: sqrt (2533.310224)

Actual: 50.332

Expected: 50.3321

[ FAILED ] SquareRootTest.PositiveNos (9 ms)

[ RUN ] SquareRootTest.ZeroAndNegativeNos

[ OK ] SquareRootTest.ZeroAndNegativeNos (0 ms)

[----------] 2 tests from SquareRootTest (0 ms total)

[----------] Global test environment tear-down

[==========] 2 tests from 1 test case ran. (10 ms total)

[ PASSED ] 1 test.

[ FAILED ] 1 test, listed below:

[ FAILED ] SquareRootTest.PositiveNos

1 FAILED TEST

Google C++ Testing Framework 的选项

在 清单 3 中，InitGoogleTest 函数接受测试基础设施的参数。本节讨论可以通过测试框架的参数实现的一些功能。

通过在命令行上传递 --gtest_output="xml:report.xml"，可以把输出转储为 XML 格式。当然，可以把 report.xml 替换为您喜欢的任何文件名。

某些测试有时候会失败，但是在大多数时候会顺利通过。这是与内存损坏相关的问题的典型特点。如果多次运行测试，就能够提高发现失败的可能性。如果在命令行上传递 --gtest_repeat=2 --gtest_break_on_failure，就重复运行相同的测试两次。如果测试失败，会自动调用调试器。

并不需要每次都运行所有测试，尤其是在修改的代码只影响某几个模块的情况下。为了支持运行一部分测试，Google 提供 --gtest_filter=<test string>。test string 的格式是由冒号 (:) 分隔的一系列通配符模式。例如，--gtest_filter=* 运行所有测试，而 --gtest_filter=SquareRoot* 只运行 SquareRootTest 测试。如果希望只运行 SquareRootTest 中的正数单元测试，应该使用 --gtest_filter=SquareRootTest.*-SquareRootTest.Zero*。注意，SquareRootTest.* 表示属于 SquareRootTest 的所有测试，而 -SquareRootTest.Zero* 表示不运行名称以 Zero 开头的测试。

清单 5 中的示例用 gtest_output、gtest_repeat 和 gtest_filter 选项运行 SquareRootTest。

清单 5. 用 gtest_output、gtest_repeat 和 gtest_filter 选项运行 SquareRootTest

[arpan@tintin] ./test_executable --gtest_output="xml:report.xml" --gtest_repeat=2 --

gtest_filter=SquareRootTest.*-SquareRootTest.Zero*

Repeating all tests (iteration 1) . . .

Note: Google Test filter = SquareRootTest.*-SquareRootTest.Z*

[==========] Running 1 test from 1 test case.

[----------] Global test environment set-up.

[----------] 1 test from SquareRootTest

[ RUN ] SquareRootTest.PositiveNos

..\user_sqrt.cpp (6854): error: Value of: sqrt (2533.310224)

Actual: 50.332

Expected: 50.3321

[ FAILED ] SquareRootTest.PositiveNos (2 ms)

[----------] 1 test from SquareRootTest (2 ms total)

[----------] Global test environment tear-down

[==========] 1 test from 1 test case ran. (20 ms total)

[ PASSED ] 0 tests.

[ FAILED ] 1 test, listed below:

[ FAILED ] SquareRootTest.PositiveNos

1 FAILED TEST

Repeating all tests (iteration 2) . . .

Note: Google Test filter = SquareRootTest.*-SquareRootTest.Z*

[==========] Running 1 test from 1 test case.

[----------] Global test environment set-up.

[----------] 1 test from SquareRootTest

[ RUN ] SquareRootTest.PositiveNos

..\user_sqrt.cpp (6854): error: Value of: sqrt (2533.310224)

Actual: 50.332

Expected: 50.3321

[ FAILED ] SquareRootTest.PositiveNos (2 ms)

[----------] 1 test from SquareRootTest (2 ms total)

[----------] Global test environment tear-down

[==========] 1 test from 1 test case ran. (20 ms total)

[ PASSED ] 0 tests.

[ FAILED ] 1 test, listed below:

[ FAILED ] SquareRootTest.PositiveNos

1 FAILED TEST

临时禁用测试

可以临时禁用测试吗？可以，只需在逻辑测试名或单元测试名前面加上 DISABLE_ 前缀，它就不会执行了。清单 6 演示如何禁用 清单 2 中的 PositiveNos 测试。

清单 6. 临时禁用测试

#include "gtest/gtest.h"

TEST (DISABLE_SquareRootTest, PositiveNos) {

EXPECT_EQ (18.0, square-root (324.0));

EXPECT_EQ (25.4, square-root (645.16));

EXPECT_EQ (50.3321, square-root (2533.310224));

}

OR

TEST (SquareRootTest, DISABLE_PositiveNos) {

EXPECT_EQ (18.0, square-root (324.0));

EXPECT_EQ (25.4, square-root (645.16));

EXPECT_EQ (50.3321, square-root (2533.310224));

}

注意，如果禁用了任何测试，Google 框架会在测试执行结束时输出警告消息，见 清单 7。

清单 7. Google 警告用户在框架中有禁用的测试

1 FAILED TEST

YOU HAVE 1 DISABLED TEST

如果希望继续运行禁用的测试，那么在命令行上传递 -gtest_also_run_disabled_tests 选项。清单 8 给出运行 DISABLE_PositiveNos 测试时的输出。

清单 8. Google 允许运行已经禁用的测试

[----------] 1 test from DISABLED_SquareRootTest

[ RUN ] DISABLED_SquareRootTest.PositiveNos

..\user_sqrt.cpp(6854): error: Value of: square-root (2533.310224)

Actual: 50.332

Expected: 50.3321

[ FAILED ] DISABLED_SquareRootTest.PositiveNos (2 ms)

[----------] 1 test from DISABLED_SquareRootTest (2 ms total)

[ FAILED ] 1 tests, listed below:

[ FAILED ] SquareRootTest. PositiveNos

断言

Google 测试框架提供一整套预定义的断言。断言分为两类 — 名称以 ASSERT_ 开头的断言和名称以 EXPECT_ 开头的断言。如果一个断言失败，ASSERT_* 断言会终止程序执行，而 EXPECT_* 断言继续运行。当断言失败时，这两者都输出文件名、行号和可定制的消息。比较简单的断言包括 ASSERT_TRUE (condition) 和 ASSERT_NE (val1, val2)。前者期望条件总是成立，而后者期望两个值不匹配。这些断言也适用于用户定义的类型，但是必须覆盖相应的比较操作符（==、!=、<= 等等）。

浮点数比较

Google 提供 清单 9 所示的宏以支持浮点数比较。

清单 9. 用于浮点数比较的宏

ASSERT_FLOAT_EQ (expected, actual)

ASSERT_DOUBLE_EQ (expected, actual)

ASSERT_NEAR (expected, actual, absolute_range)

EXPECT_FLOAT_EQ (expected, actual)

EXPECT_DOUBLE_EQ (expected, actual)

EXPECT_NEAR (expected, actual, absolute_range)

为什么需要用单独的宏进行浮点数比较？使用 ASSERT_EQ 不行吗？使用 ASSERT_EQ 和相关的宏可能可以，也可能不行，但是使用专门用于浮点数比较的宏更好。通常，不同的中央处理单元 (CPU) 和操作环境以不同的方式存储浮点数，简单地比较期望值和实际值是无效的。例如，ASSERT_FLOAT_EQ (2.00001, 2.000011) 会顺利通过 — 如果直到小数点后四位都匹配，Google 就不会抛出错误。如果需要更精确的比较，应该使用 ASSERT_NEAR (2.00001, 2.000011, 0.0000001)，就会得到 清单 10 所示的错误。

清单 10. ASSERT_NEAR 产生的错误消息

Math.cc(68): error: The difference between 2.00001 and 2.000011 is 1e-006, which exceeds

0.0000001, where

2.00001 evaluates to 2.00001,

2.000011 evaluates to 2.00001, and

0.0000001 evaluates to 1e-007.

死亡测试

Google C++ Testing Framework 有一类有趣的断言（ASSERT_DEATH、ASSERT_EXIT 等），它们称为死亡断言。使用这种断言检查在例程的输入错误的情况下是否发出正确的错误消息，或者例程是否退出并返回正确的退出码。例如，在 清单 3 中，当执行 square-root (-22.0) 时应该产生错误消息，程序退出，返回状态应该是 -1 而不是 -1.0。清单 11 使用 ASSERT_EXIT 检查是否是这样。

清单 11. 使用 Google 框架运行死亡测试

#include "gtest/gtest.h"

double square-root (double num) {

if (num < 0.0) {

std::cerr << "Error: Negative Input\n";

exit(-1);

}

// Code for 0 and +ve numbers follow…

}

TEST (SquareRootTest, ZeroAndNegativeNos) {

ASSERT_EQ (0.0, square-root (0.0));

ASSERT_EXIT (square-root (-22.0), ::testing::ExitedWithCode(-1), "Error:

Negative Input");

}

int main(int argc, char **argv) {

::testing::InitGoogleTest(&argc, argv);

return RUN_ALL_TESTS();

}

ASSERT_EXIT 检查函数是否退出并返回正确的退出码（即 exit 或 _exit 例程的参数），对引号中的字符串和函数发送到标准错误的字符串进行比较。注意，错误消息必须发送到 std::cerr 而不是 std::cout。清单 12 给出 ASSERT_DEATH 和 ASSERT_EXIT 的原型。

清单 12. 死亡断言的原型

ASSERT_DEATH(statement, expected_message)

ASSERT_EXIT(statement, predicate, expected_message)

Google 提供预定义的谓词 ::testing::ExitedWithCode(exit_code)。只有在程序退出且退出码与谓词中的 exit_code 相同的情况下，这个谓词的结果才是 true。ASSERT_DEATH 比 ASSERT_EXIT 简单；它只检查标准错误中的错误消息是否是用户期望的消息。

理解测试装备

在执行单元测试之前，通常要执行一些定制的初始化。例如，如果希望度量测试的时间/内存占用量，就需要放置一些测试专用代码以度量这些值。这就是装备的用途 — 它们帮助完成这种定制的测试初始化。清单 13 给出一个装备类的示例。

清单 13. 测试装备类

class myTestFixture1: public ::testing::test {

public:

myTestFixture1( ) {

// initialization code here

}

void SetUp( ) {

// code here will execute just before the test ensues

}

void TearDown( ) {

// code here will be called just after the test completes

// ok to through exceptions from here if need be

}

~myTestFixture1( ) {

// cleanup any pending stuff, but no exceptions allowed

}

// put in any custom data members that you need

};

这个装备类派生自 gtest.h 中声明的 ::testing::test 类。清单 14 是使用这个装备类的示例。注意，它使用 TEST_F 宏而不是 TEST。

清单 14. 装备的使用示例

TEST_F (myTestFixture1, UnitTest1) {

….

}

TEST_F (myTestFixture1, UnitTest2) {

….

}

在使用装备时，要注意以下几点：

可以在构造函数或 SetUp 方法中执行初始化或分配资源。由用户选择具体方式。

可以在 TearDown 或析构函数例程中释放资源。但是，如果需要异常处理，那么只能在 TearDown 代码中进行，因为从析构函数中抛出异常会导致不确定的结果。

在以后的版本中，Google 断言宏可能会在平台上抛出异常。因此，为了便于维护，最好在 TearDown 代码中使用断言宏。

并不跨多个测试使用同一个测试装备。对于每个新的单元测试，框架创建一个新的测试装备。在 清单 14 中，由于要创建两个 myFixture1 对象，所以两次调用 SetUp 例程（请注意使用正确的拼写）。

结束语

本文仅仅触及了 Google C++ Testing Framework 的皮毛。可以从 Google 网站获得关于这个框架的详细信息。对于高级开发人员，我建议阅读 Boost 单元测试框架和 CppUnit 等开放回归框架方面的其他文章。更多信息参见 参考资料。

关于作者

Arpan Sen 是致力于电子设计自动化行业的软件开发首席工程师。他使用各种 UNIX 版本（包括 Solaris、SunOS、HP-UX、IRIX，以及 Linux 和 Microsoft Windows）已经多年。他热衷于各种软件性能优化技术、图论和并行计算。Arpan 获得了软件系统硕士学位。