Tomsdinary

如何用VC6.0集成开发环境来构建MASM32汇编的编程环境

843858859@qq.com(Tomsdinary) — Tue, 24 Nov 2009 11:35:12 GMT

http://www.360doc.com/content/090203/10/59579_2446700.html

如何用VC6.0集成开发环境来构建MASM32汇编的编程环境（原创）

作者：maxzhou88（周哥）

　开发高性能的程序少不了用汇编编程，限于C语言中内嵌汇编语言的局限（如在C代码中混合汇编语言编程时，很难实现跳表)，一些代码必须书写在独立的汇编源文件中。遗憾的是，在调试时，只能看到裸的汇编码，而不能到懂标号，变量等，现在能这样C与ASM混合编程就方便多了。

编程环境：VC6.0，Masm32v8

优点：
[1] 使用VC6.0集成开发环境可以利用其强大的Debug功能来实现源代码级调试(Source Code Debug),（看变量、设置断点、查看MASM32的高级命令展开......）
[2] 使用VC6.0的资源编辑器，可视化编辑资源。
[3] 实现C/C++与ASM的混合编程。
[4] 在窗口下比在CMD下工作符合一般人的习惯，再也不需要写makefile文件或xxx.bat文件了。

方法：
[1] 安装VC6.0，这个我就说了，大家都会的哦,一般我将它安装在 C:\Program Files\ Microsoft Visual Studio。
[2] 安装MASMv8.exe,一般我将它安装在 D:\MASM32 下。
[3] 将Win32ASM（masm32）中的ml.exe和ml.err拷贝到C:\Program Files\ Microsoft Visual Studio\VC98\Bin
[4] 使用VC6.0新建一个空工程，如：hello（类型为：win32 console、win32 application、DLL等均可）。
[5] 把汇编和资源文件拷至新建工程目录下（hello.asm，hello.rc），并把这些文件加入工程中(将*.asm添加到Source Files, 将*.rc添加到Resource Files)。
[6] 配置IDE（这就配置一次就搞定）：在VC的菜单tools/option…/paths(include files)中添加一个路径d:\MASM32\INCLUDE
[7] 配置工程（每个工程都要这样配置）：打开工程设置（project settings）,点击*.asm文件选择（Custom Build）,
命令中加上： ml /c /coff /Zi /Fo$(TargetDir)\$(InputName).obj $(InputPath)
输出中加上： $(TargetDir)\$(InputName).obj
注意选Settings for: Win32 Debug 和 Win32 release，将上面的两条都加上，而且每个*.ASM文件（如有多个ASM时）都这样设置。

[8] 点击VC的编译（build）就可以运行了哦。

至此就可以使用VC调试器源码级调试汇编程序了，可以设置断点，察看变量、内存、寄存器等，masm出现语法错误时可以双击output window中的错误行定位到程序中的指定行。
为了不在debug和release目录中产生超大的预编译头文件xxxx.pch,在工程设置（project settings）中的C/C++ -> Precompiled Headers的选项上选择"不使用预编译头",其实就现在的电脑而言,不使用预编译头也能快速地编译C代码的哦.

资源编译/编辑器蛮好用的.只是还有个问题我也没有搞懂:VC6.0的资源编译/编辑器不支持16进制的资源ID,非要用10进制的,我是用两种方法解决的:一是将资源文件*.rc中的ID改成10进制，这样就可以编辑修改了；二是直接用老罗书中的rc文件导入,但在VC6.0中不要打开编辑它就可以了. 有人能告诉我VC6.0的资源编辑器用16进制ID的方法嘛,可能这很简单,我没有去深究罢了.

有空来踩踩我的空间哦:http://hi.baidu.com/maxzhou88
该文在我的百度空间:http://hi.baidu.com/maxzhou88/blog/item/7c7b4b09181ce186d1581b8f.html
Win32 C++/ASM 混合编程的Demo下载: http://maxzhou88.ys168.com/pc

我在学老罗的MASM32程序时都是象这样在VC6.0的集成环境下工作的，他书中的例子我基本都试验过，比在DOS（CMD窗口）下方便多了，也不要什么makefile文件，建个proj项目就搞定，最重要的是用VC的资源编辑器来编辑资源比原先手工编辑方便多了，如果有什么问题欢迎大家交流哦！

周哥（maxzhou88）写于 2009-01-21

为了方便大家配置VC6.0 ，我在这里贴两张图：

　　
这是配置项目中每个ASM文件的Custom Build 注意：Debug 和 Release 版本都要设置)

这是配置VC6.0的IDE，就设置一遍就搞定了。

不过这两张图是我百度空间的，但百度是不提供图片外链服务的哦！别急，先分别右击这两张图的图框，在弹出菜单的“属性”中COPY图片的URL地址，然后将地址在IE中打开，这时图片就下载你机器的IE缓冲区中，再将这个看不到图的页面按F5刷新一下，哈哈！IE就直接从缓冲区中取图了，你也就看得见了。没有办法啊，对不能外链的图就只能这样麻烦得做了哦。

另外，我在调试MASM32程序时还经常开CMD窗来实时查看变量，这也是种很好的Debug方法，其实在Win32下无所谓 windows窗口程序和console 控制台程序，也就是说在建立工程时可以选console 控制台程序类型来写windows窗口程序，反之亦然。我一般是这样做的，先将工程以windows窗口程序类型来建立新工程，当要用CMD窗口来调试输出变量时，我就将工程的link选项卡中的Project options中的subsystem:windows 换成 subsystem:console就可以了，这时候编译连接后程序运行就会出CMD窗口，当调试完后再改回subsystem:windows即可。

CMD控制台输出的代码片段如下:

.data?
szBuffer db 'hello the world' ,0dh, 0ah ;要调试的输出内容
hStdOut dd ? ;控制台标准输出句柄，在CMD中是默认打开的
dwBytesWrite dd ?
;用下列语句就可以实现CMD的输出
invoke WriteConsole, hStdOut, addr szBuffer, sizeof szBuffer, addr dwBytesWrite, NULL

C语言版生产者消费者 Windows平台

843858859@qq.com(Tomsdinary) — Mon, 23 Nov 2009 12:15:58 GMT

#include
#include
#define SIZE 20
int in, out;
int buffer[SIZE];
HANDLE hFull;
HANDLE hEmpty;
HANDLE hMutex;
unsigned int _stdcall Producer (void* )
{
int x=0;
for ( ;; )
{
::WaitForSingleObject(hFull, INFINITE);
::WaitForSingleObject(hMutex, INFINITE);
buffer[in]=x++;
printf("produce %d\n", buffer[in]);
in=(in+1)%SIZE;
::ReleaseMutex(hMutex);
::ReleaseSemaphore(hEmpty, 1, NULL);
}
return 0;
}
unsigned int _stdcall Customer (void* )
{
int y;
for ( ;; )
{
::WaitForSingleObject(hEmpty, INFINITE);
::WaitForSingleObject(hMutex, INFINITE);
y=buffer[out];
out=(out+1)%SIZE;
printf("consume %d\n", y);
::ReleaseMutex(hMutex);
::ReleaseSemaphore(hFull, 1, NULL);
::Sleep(1000);
}
return 0;
}
int _tmain(int argc, _TCHAR* argv[])
{
in=out=0;
hFull=::CreateSemaphore(NULL, SIZE, SIZE, NULL);
hEmpty=::CreateSemaphore(NULL, 0, SIZE, NULL);
hMutex=::CreateMutex(NULL, FALSE, NULL);
HANDLE hProducer=(HANDLE)::_beginthreadex(NULL, 0, Producer, NULL, 0, NULL);
HANDLE hCustomer=(HANDLE)::_beginthreadex(NULL, 0, Customer, NULL, 0, NULL);
::WaitForSingleObject(hCustomer, INFINITE);
::CloseHandle(hMutex);
::CloseHandle(hFull);
::CloseHandle(hEmpty);
::CloseHandle(hProducer);
::CloseHandle(hCustomer);

return 0;
}

Java版生产者消费者模型

843858859@qq.com(Tomsdinary) — Mon, 23 Nov 2009 12:13:26 GMT

package book.thread.product;
/**
* 产品的仓库类
* 内部采用数组来表示循环队列，以存放产品。
*/
public class Warehouse {
//仓库的容量
private static int CAPACITY = 11;
//仓库里的产品
private Product[] products;

//[front, rear)区间的产品是未被消费的
//当前仓库中第一个未被消费的产品的下标
private int front = 0;
//仓库中最后一个未被消费的产品的下标加1
private int rear = 0;
public Warehouse(){
this.products = new Product[CAPACITY];
}
public Warehouse(int capacity) {
this();
if (capacity > 0){
CAPACITY = capacity + 1;
this.products = new Product[CAPACITY];
}
}
/**
* 从仓库获取一个产品
*/
public Product getProduct() throws InterruptedException {
synchronized (this) {
//标志消费者线程是否还在运行
boolean consumerRunning = true;
//获取当前线程
Thread currentThread = Thread.currentThread();
if (currentThread instanceof Consumer){
consumerRunning = ((Consumer)currentThread).isRunning();
} else {
//非消费者不能获取产品
return null;
}
//如果仓库中没有产品，而且消费者线程还在运行，则消费者线程继续等待。
while ((front == rear) && consumerRunning){
wait();
consumerRunning = ((Consumer)currentThread).isRunning();
}
//如果消费者线程已经没有运行了，则退出该方法，取消获取产品
if (!consumerRunning){
return null;
}
//取当前未被消费的第一个产品
Product product = products[front];
System.out.println("Consumer[" + currentThread.getName()
+ "] getProduct: " + product);
//将当前未被消费产品的下标后移一位，如果到了数组末尾，则移动到首部。
front = (front + 1 + CAPACITY) % CAPACITY;
System.out.println("仓库中还没有被消费的产品数量："
+ (rear + CAPACITY - front) % CAPACITY);
//通知其他等待线程
notify();
return product;
}
}
/**
* 向仓库存储一个产品
*/
public void storageProduct(Product product) throws InterruptedException {
synchronized (this) {
//标志生产者线程是否在运行
boolean producerRunning = true;
//获取当前线程
Thread currentThread = Thread.currentThread();
if (currentThread instanceof Producer){
producerRunning = ((Producer)currentThread).isRunning();
} else {
//不是生产者不能存储产品
return;
}
//如果最后一个未被消费产品与第一个未被消费的产品的下标紧挨着，
//则说明没有存储空间，如果没有存储空间而且生产者线程还在运行，则等待仓库释放产品。
while (((rear + 1) % CAPACITY == front) && producerRunning) {
wait();
producerRunning = ((Producer)currentThread).isRunning();
}
//如果生产者线程已经停止了，则停止产品的存储。
if (!producerRunning){
return;
}
//保存参数产品到仓库
products[rear] = product;
System.out.println("Producer[" + Thread.currentThread().getName()
+ "] storageProduct: " + product);
//将rear下标循环后移一位
rear = (rear + 1) % CAPACITY;
System.out.println("仓库中还没有被消费的产品数量："
+ (rear + CAPACITY - front) % CAPACITY);
notify();
}
}
}
package book.thread.product;
/**
* 生产者类，采用线程，模拟生产者的行为
*/
class Producer extends Thread {
// 生产者存储产品的仓库
private Warehouse warehouse;
// 产品的名字
private static int produceName = 0;
//是否需要结束线程的标志位
private boolean running = false;
public Producer(Warehouse warehouse, String name) {
super(name);
this.warehouse = warehouse;
}
public void start(){
this.running = true;
super.start();
}
public void run() {
Product product;
try {
while (running) {
//生产并存储产品
product = new Product((++produceName) + "");
this.warehouse.storageProduct(product);
sleep(300);
}
} catch (InterruptedException ie) {
ie.printStackTrace();
}
}
/**
* 停止生产者线程
*/
public void stopProducer(){
synchronized (warehouse){
this.running = false;
//通知等待仓库的线程
warehouse.notifyAll();
}
}
//生产者线程是否在运行
public boolean isRunning() {
return running;
}
}
package book.thread.product;
/**
*消费者，采用线程，模拟消费者行为
*/
class Consumer extends Thread {
//消费者获取产品的仓库
private Warehouse warehouse;
//是否需要结束线程的标志位
private boolean running = false;
public Consumer(Warehouse warehouse, String name) {
super(name);
this.warehouse = warehouse;
}
public void start(){
this.running = true;
super.start();
}

public void run() {
Product product;
try {
while (running) {
//从仓库中获取产品
product = warehouse.getProduct();
sleep(500);
}
} catch (InterruptedException ie) {
ie.printStackTrace();
}
}
/**
* 停止消费者线程
*/
public void stopConsumer(){
synchronized (warehouse){
this.running = false;
//通知等待仓库的线程
warehouse.notifyAll();
}
}
//消费者线程是否在运行
public boolean isRunning() {
return running;
}
}
package book.thread.product;
/**
* 产品类
*/
public class Product {
//产品名
private String name;

public Product(String name){
this.name=name;
}
public String toString() {
return "Product-" + name;
}
}
package book.thread.product;
/**
* 测试生产者——消费者
* 支持多个生产者和消费者
*/
public class TestProduct {
public static void main(String[] args) {
//建立一个仓库，容量为10
Warehouse warehouse = new Warehouse(10);

//建立生产者和消费者
Producer producers1 = new Producer(warehouse, "producer-1");
Producer producers2 = new Producer(warehouse, "producer-2");
Producer producers3 = new Producer(warehouse, "producer-3");
Consumer consumers1 = new Consumer(warehouse, "consumer-1");
Consumer consumers2 = new Consumer(warehouse, "consumer-2");
Consumer consumers3 = new Consumer(warehouse, "consumer-3");
Consumer consumers4 = new Consumer(warehouse, "consumer-4");
//启动生产者和消费者线程
producers1.start();
producers2.start();
consumers1.start();
producers3.start();
consumers2.start();
consumers3.start();
consumers4.start();
//让生产者消费者程序运行1600ms
try {
Thread.sleep(1600);
} catch (InterruptedException e) {
e.printStackTrace();
}
//停止生产者和消费者的线程
producers1.stopProducer();
consumers1.stopConsumer();
producers2.stopProducer();
consumers2.stopConsumer();
producers3.stopProducer();
consumers3.stopConsumer();
consumers4.stopConsumer();
}
}

我的第一个MASM32窗口应用

843858859@qq.com(Tomsdinary) — Mon, 23 Nov 2009 05:34:48 GMT

.386
.model flat, stdcall
option casemap:none
include windows.inc
include gdi32.inc
includelib gdi32.lib
include user32.inc
includelib user32.lib
include kernel32.inc
includelib kernel32.lib
.data?
hInstance dd ?
hWinMain dd ?
.const
szClassName db 'MyClass', 0
szCaptionMain db 'My first Window', 0
szText db 'Win32 Assembly, Simple and powerful', 0
.code

WindowProc_ proc uses ebx edi esi,
hWnd:dword, message:dword, wParam:dword, lParam:dword
local @stPs:PAINTSTRUCT
local @stRect:RECT
local @hDC:dword

mov eax, message
.if eax == WM_PAINT
invoke BeginPaint, hWnd, addr @stPs
mov @hDC, eax
invoke GetClientRect, hWnd, addr @stRect
invoke DrawText, @hDC, addr szText, -1, addr @stRect, DT_SINGLELINE or DT_CENTER or DT_VCENTER
invoke EndPaint, hWnd, addr @stPs
.elseif eax == WM_CLOSE
invoke DestroyWindow, hWinMain
invoke PostQuitMessage, NULL
.else
invoke DefWindowProc, hWnd, message, wParam, lParam
ret
.endif
xor eax, eax
ret
WindowProc_ endp
WinMain_ proc
local @stWndClass:WNDCLASSEX
local @stMsg:MSG
invoke GetModuleHandle, NULL

mov hInstance, eax
invoke RtlZeroMemory, addr @stWndClass, sizeof @stWndClass
invoke LoadCursor, 0, IDC_ARROW
mov @stWndClass.hCursor, eax
push hInstance
pop @stWndClass.hInstance
mov @stWndClass.cbSize, sizeof WNDCLASSEX
mov @stWndClass.lpfnWndProc, offset WindowProc_
mov @stWndClass.hbrBackground, COLOR_WINDOW+1
mov @stWndClass.lpszClassName,offset szClassName
invoke RegisterClassEx,addr @stWndClass
invoke CreateWindowEx,WS_EX_CLIENTEDGE,\
offset szClassName,offset szCaptionMain,\
WS_OVERLAPPEDWINDOW,\
100,100,600,400,\
NULL,NULL,hInstance,NULL
mov hWinMain,eax
invoke ShowWindow,hWinMain,SW_SHOWNORMAL
invoke UpdateWindow,hWinMain
.while TRUE
invoke GetMessage,addr @stMsg,NULL,0,0
.break .if eax == 0
invoke TranslateMessage,addr @stMsg
invoke DispatchMessage,addr @stMsg
.endw
ret
WinMain_ endp
start:
call WinMain_
invoke ExitProcess,NULL
end start

我的第一个MASM32应用

843858859@qq.com(Tomsdinary) — Mon, 23 Nov 2009 05:34:04 GMT

.386
.model flat, stdcall
option casemap:none
include windows.inc
include user32.inc
includelib user32.lib
include kernel32.inc
includelib kernel32.lib
.data
　　szCaption db 'I love you', 0
　　szText db 'Happy birthday to you', 0
.code
start:
　　invoke MessageBox, NULL, offset szText, offset szCaption, MB_OK or MB_ICONINFORMATION
　　invoke ExitProcess, NULL
end start

Java线程同步

843858859@qq.com(Tomsdinary) — Sat, 21 Nov 2009 04:36:00 GMT

　　注：wait notify 都是Object的方法
同步（阻塞）：是一种防止对共享资源访问导致的数据不一致的一种模式。
详细请参看操作系统。

在Java中，由于对多线程的支持，对同步的控制主要通过以下几个方法，synchronized，和wait(),notify()和notifyAll(),下面进行一一的讲解：

A关键字synchronized
每个java对象都有一把锁，当有多个线程同时访问共享资源的时候，需要Synchronize 来控制安全性， synchronize 分 synchronize 方法和synchronize块，使用synchronize块时，一定要显示的获得该对象的锁（如synchronize（object))而方法则不需要。
java的内存模型是对每一个进程有一个主内存，每个线程有自己的内存，他们从主内存中取数据，然后计算，再存入主内存中。
并发问题如下：如果多个线程同事操作同一数据， A线程从主内存中取的I的值为1，然后进行加1操作，这时B线程也取I的值，进行加2操作，然后A存入2到主内存中， B也存入，这样就覆盖了A的值（同数据库中的并发问题一样）。
解决办法是用synchronize，如用synchronized（I）。被synchronize 修饰的方法（块）把以下三步操作当成一个原子操作：取数据，操作数据，存数据。我们知道原子操作是不可以被打断的，所以其保证了数据一致性，这样同一时间只有一个线程再执行，对性能有一定的影响。这也是synchronize的第二个作用：保证统一时间只有一个线程再运行。当实现SOCKET连接的时候经常用到.
JAVA中规定对非FLOAT, LONG的原始类型的取和存操作为原子操作。其实就是对一个字（32位）的取，存位原始操作，因为FLOAT, LONG为两个字节的长度，所以其取，存为非原子操作。如果想把他们也变为原子操作，可以用VOLATILE关键字来修饰

使用方法：
作用区域主要有两种：
1.方法
2.代码块
被synchronized声明的方法被称为同步方法，被其修饰的代码块称为同步语句。无论是同步方法还是同步语句，只要声明为同步了，在同一时刻，同一个对象的同步XX是不可以被同时访问的，而不同对象之间的同步方法是互不干扰的。

具体实现（如下代码都在某个类定义中）：
同步方法：
Public synchronized void change() {
//
}

同步语句：（因为效率问题，有时考虑使用同步语句块）
Public void change() {
Synchronized(this) {

}
}
这个同步语句是针对当前对象的，有时，我们就是想让一段代码同步，可能与当前对象并没什么关系，可以自定义同步的锁。如下：
private byte[] lock= new byte[0];

Public void change() {
Synchronized(lock) {

}
}
自定义锁注意事项：
1必须是private，防止在类外部引用改变。
2如果可能用到，重写get方法，返回对象的clone,而不是本身。

其他用法：
Synchronized除了可以作用于方法，代码块，还可以作用于静态方法，类，某个实例。但是都存在效率问题，一定要慎用。

Class Foo 　　{ 　　

public synchronizedstatic void methodAAA()// 同步的static 函数　　
{ 　　

//….　　

} 　
　 public void methodBBB() 　　{ 　　

synchronized(Foo.class)// class literal(类名称字面常量)　

　} }
这样修饰后代表的是：统一时刻，被修饰部分只有一个对象可以运行，因为它的声明是针对类的。

2.wait()/notify()/notifyAll()

注意：
在Java中，每个对象都有个对象锁标志(Object lock flag)与之想关联，当一个线程A调用对象的一段synchronized代码时，
它首先要获取与这个对象关联的对象锁标志，然后执行相应的代码，执行结束后，把这个对象锁标志返回给对象；因此，在线程A执行
synchronized代码期间，如果另一个线程B也要执行同一对象的一段synchronized代码时（不一定与线程A执行的相同），它将
要等到线程A执行完后，才能继续....

如何利用wait() notify() notifyAll()?

在synchronized代码被执行期间，线程可以调用对象的wait()方法，释放对象锁标志，进入等待状态，并且可以调用notify()或者
notifyAll()方法通知正在等待的其他线程。notify()通知等待队列中的第一个线程，notifyAll()通知的是等待队列中的所有线程

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/weizhaozhe/archive/2009/02/22/3922647.aspx

谷歌操作系统没有技术含量

843858859@qq.com(Tomsdinary) — Sat, 21 Nov 2009 02:11:09 GMT

1、启动快速是Linux+SSD的功劳。从国外的网站得知，现在版本的谷歌操作系统启动时间是7秒钟，这个成绩只能说还好，并且不能完全算谷歌的功劳。假设一个没有预装任何应用、新装的简化版本Linux，加上一个飞速的SSD固态硬盘，也差不多就是这个时间了。

而对比一下Windows 7，如果同样的硬件环境，会稍长一些，但并不让人抓狂。

2、所有应用都基于Web，这是Chrome浏览器+一堆web应用的功劳。从这个意义上来说，谷歌操作系统的发布，其实是它苦心经营多年的最后一步而已。在谷歌的思想中，操作系统唯一存在的价值，就是让Chrome浏览器能运行、并正常访问互联网，仅此而已。

3、全新的安全计算模式，差不多就是有了验证机制的还原精灵。由于所有行为都在浏览器中操作，所有数据都存于云端，所以谷歌操作系统无需考虑数据备份、数据安全问题，这就意味着，它能随意让操作系统重新恢复不管病毒、木马如何攻击你的系统，一切清零即可。

所以我认为单纯讲谷歌操作系统没有什么技术含量可言，但这并不代表我不欣赏它，更不代表它未来没有市场。所谓技术含量与市场占有率，根本就没有什么逻辑关系。如果谷歌操作系统能够成功击败Windows，最大的功臣应该是谷歌一切以网络为中心的思想，最重要的工具应该是Chrome浏览器。

但我还要提出一个观点：在未来的很长时间里，谷歌操作系统依然还只能是个玩具，它尚不具备与Windows抗衡的整体实力。不是它不够出色，而是谷歌需要芯片厂商、软件商、开发者、PC厂商等诸多盟友的支持。

但问题可能就在这里，对于那些诞生在Windows同时代的软件商们，他们已经习惯了靠收取授权费过活，它们的经营思路很多都是与互联网相悖的，要说服它们，不是那么容易。更何况，谷歌操作系统本身在砸很多人的饭碗。

总之，谷歌操作系统不是一件技术的事，是一件利益重新划分的事。

谷歌Chrome OS说明会：失望大于希望？

843858859@qq.com(Tomsdinary) — Sat, 21 Nov 2009 01:56:12 GMT

http://news.csdn.net/a/20091120/215051.html

这两天，谷歌发布Chrome OS的消息引得人们格外关注和期待。为此笔者在此前写了篇对于此款操作系统提前发布的文章，提出了自己的一些困惑。还好，就在这篇文章的两天后，今天凌晨，谷歌在美国举行了Chrome OS的说明会。这至少验证了笔者之前的判断，谷歌此次只是说明会，而非发布，因为其一是根本不会提供用户的下载，其二是笔者之前文章的困惑在谷歌的说明会上基本没有找到答案，三是在Chrome操作系统新闻说明会上，谷歌产品副总裁Sundar Pichai就上市时间明确表态，2010年假期前有可能发布。不过通过说明会上再简单不过的演示，笔者对于谷歌的Chrome OS还是有了些比较模糊的认识。

是Chrome浏览器的翻版吗？至少从界面上看，实在是太像了。唯一不同的是，在这个浏览器中，多了些谷歌称之为的Panel的东西，就是应用程序吧。当然这些应用程序基本是都是谷歌自己的在线应用程序。例如Gmail、Google Doc等。点击后就会链接到谷歌相关应用程序的网站运行。从这点上看，这些所谓Panel图表更像是一个个应用网站的链接。如果这就是最终Chrome OS的界面的话，这样的操作系统可以称之为操作系统吗？不就是在Chrome浏览器中加了些链接吗？从谷歌说明会一上来，谷歌副总裁Sundar Pichai就大谈Chrome浏览器就知道谷歌Chrome OS与Chrome浏览器的密切关系，但令笔者没有想到的是这种密切竟然让人误以为Chrome OS就是Chrome浏览器，当然除了界面外，还有那再简单不过的应用链接。

是免费的操作系统吗？之前，业内和人们为谷歌Chrome OS兴奋不已和充满期待的一个重要原因是谷歌的Chrome OS会像谷歌多数的产品一样免费提供给用户使用。例如用户可以免费下载或者OEM厂商免费预装到PC中。不过谷歌今天的说明会中提及的预装方式，至少让用户可以免费下载这条路已经行不通了。之前笔者曾经撰文称谷歌操作系统推广的关键在PC中的预装，否则用户根本没有必要再去安装一个操作系统，即使是免费下载。看谷歌还是很清楚这点的。此外，预装谷歌Chrome OS操作系统的PC（硬件）厂商都是要经过谷歌验证的，这意味着OEM厂商预装时是要付费的，就是付费多少的问题了。还有就是谷歌之所以采取这种策略，还在于可以巧妙地回避其硬件兼容性差的软肋。

用户选择终端会受限和被绑定吗？从谷歌说明会上的介绍看，不支持硬盘，与OEM厂商的认证等可以确认的是，用户未来选择终端的类型可能会受到限制。例如拿谷歌称的未来主要支持上网本看，首先主流的笔记本用户将无法使用谷歌的Chrome OS。此外，就是在上网本市场，用户选择上网本的种类（包括同一厂商的）也要依据OEM厂商预装的数量和种类而定。而用户一旦选择了预装有Chrome OS的上网本，将无法安装别的系统和应用，用户有被利用Chrome OS绑定某一OEM厂商硬件上的危险。换言之，用户购买的某一预装有Chrome OS的上网本，只能运行这个系统和基于其上的应用（主要是谷歌的在线应用），否则就只能是个摆设。难怪谷歌在说明会上称，希望使用谷歌Chrome OS系统的用户，最好还有另外的一台PC（笔记本）。言外之意，装有Chrome OS的笔记本将是Google系统和应用的专有平台。

离线后的应用将无法运行吗？从说明会上的演示看，用户在登陆进入谷歌的Chrome OS系统后只有始终在线，才能运行日常的一些程学（例如文字处理、游戏等），一旦离线，所有的应用都将被终止。因为Chrome OS不支持硬盘，同时谷歌声称出于安全性的考虑，Chrome OS不支持任何程序的安装。这很符合谷歌的希望用户始终在线的战略，但以操作系统的形式强制用户滞留在网上这种做法确实值得商榷。其次，这种操作系统的机制还会导致，除了断网，一旦没有网络，用户的终端将一无是处。不过人家谷歌已经解释了，Chrome OS使得用户的PC更像是一个大的缓存，只不过这个缓存的代价对于用户来说是不是太大了。有限的应用，无法替换的系统、始终在线和由此而被绑定的终端。
除了这些模糊认识之外，笔者认为谷歌此次说明会上总结的谷歌Chrome OS的快速性、易用性以及安全性的特点也令人比较模糊，尤其是在上述的模糊未能清晰前。类似于浏览器的操作系统（不知与Chrome浏览器机制是否有很大的相似性），启动一个浏览器自然比启动一个真正的操作系统要快得多，这也是为何谷歌在说明会上提出对于之前的Chrome浏览器进行了20多次改进的原因。至于易用性，在界面上点击几个网站的链接，自然比运行一个程序要简单得多，而安全性，不让任何非谷歌认证程序的本地运行和安装（而且没有硬盘），自然是安全的，而且这个系统只是充当硬缓存的作用，只要谷歌服务器那边安全性没有问题的话。但这些有想放一部分是在牺牲掉了用户选择、使用和便利的前提下获得的。

总之通过谷歌的这次说明会，笔者认为这符合谷歌的互联网战略，但对于市场和用户而言，确是失望大于希望。所幸的是，距离谷歌正式发布Chrome OS还有近一年的时间，希望谷歌到时候真的可以带给市场和用户以惊喜。

VC10中的C++0x特性 part 3 (1)：声明之类型

843858859@qq.com(Tomsdinary) — Sat, 21 Nov 2009 01:25:08 GMT

今天我要讲 decltype，它让完美转发函数能够返回任意类型的东西。对编写高度泛型的人来说这是很有趣的的特性。

返回类型问题

C++98/03 有一个有意思的盲点：给定一个像 x * y 的表达式， x 和 y 是任意类型，你却没法知道 x * y 的类型。假如 x 是 Watts 类型的， y 是 Seconds 类型的，那 x * y 的类型可能会是 Joules 类型的。给定声明 print(const T& t)，调用 print( x * y ) ，在这里 T 会被推导为 Joules 类型。但反过来却不是这样的：当你写个函数 multiply(const A& a, const B& b) ，你无法指定它的通用返回类型。即使是实例化成 multiply() ，编译器也晓得 x * y 的类型，但你就是没办法得到那样的信息（指返回类型）。C++0x 中的关键词 decltype 扫除了这个盲点，让你能够说“ multiply() 返回 x * y 类型的东西”。（decltype 是 "declared type" 的缩写，我把它读作谐音 “speckle type”。）

decltype：模式

下面是一个完全泛化的封装 +() 操作符的函数因子。这个“加法”因子不是一个模板，但它有一个模板函数，这个模板函数带两个任意类型（当然是不同类型的）参数，并把它们想加，然后返回任意类型（可能跟两个参数的类型完全不同）的结果。C:\Temp>type plus.cpp
#include
#include
#include
#include
#include
#include
#include
using namespace std;

struct Plus {
template
auto operator()(T&& t, U&& u) const
-> decltype(forward(t) + forward(u)) {
return forward(t) + forward(u);
}
};

int main() {
vector i;
i.push_back(1);
i.push_back(2);
i.push_back(3);

vector j;
j.push_back(40);
j.push_back(50);
j.push_back(60);

vector k;
vector s;
s.push_back("cut");
s.push_back("flu");
s.push_back("kit");

vector t;
t.push_back("e");
t.push_back("ffy");
t.push_back("tens");

vector u;

transform(i.begin(), i.end(), j.begin(), back_inserter(k), Plus());
transform(s.begin(), s.end(), t.begin(), back_inserter(u), Plus());

for_each(k.begin(), k.end(), [](int n) { cout << n << " "; });
cout << endl;

for_each(u.begin(), u.end(), [](const string& r) { cout << r << " "; });
cout << endl;
}

C:\Temp>cl /EHsc /nologo /W4 plus.cpp
plus.cpp

C:\Temp>plus
41 52 63
cute fluffy kittens

拿 C++98/03 中的 std::plus (在 C++0x 没有变动)来作对比，后者是一个类模板，你不得不传递模板参数类型来调用 plus() 和 plus()，重复声明一次元素类型。并且后者那个形式为 T operator()(const T& x, const T& y) 的非模板函数调用操作符，如果不借助于隐式类型转换，就不能将两种不同类型的东西相加，更不用说 3 种不同类型的情况了（译注：两个参数类型 + 一个返回类型）。（你可以传递 string 和 const char * 类型的实参来调用 const plus()，那样的话就会在串接操作之前，基于第二个参数(const char *)构建一个临时 string，这样做在性能上不可取）。再者，因为它的参数是 const T& 形式的，这就不能使用 C++0x 的 move 语意来获得好处。Plus 避免了上述问题：调用 Plus() 不需要重复声明元素的类型，它也可以处理 “3 种” 不同类型的情况，并且它用了完美转发，因而能够使用 move 语意。

trailing return type

现在让我们再来看看这个模板函数调用操作符：

template
auto operator()(T&& t, U&& u) const
-> decltype(forward(t) + forward(u)) {
return forward(t) + forward(u);
}

这里的 auto 与 for ( auto i = v.begin(); i != v.end(); ++i) 中的含义完全不同, 在 for 中它是指“把用来初始化对象的类型当做对象的类型”，而在这里它是指“这个函数有 trailing-return-type，只有指定实参之后，才能确定它返回什么类型”(C++0x 提案 N2857 中把这个称作 “late-specified return type”，但它将被重命名为 “trailing-retrun-type”（提案 N2859 ）)。这里看起来和 lambda 函数是如何指定返回类型的很相似，其实它们就是一样的。lambda 函数的返回类型必须出现在 lambda 导引符 [] 之后（右边）。在这里，decltype-powered 类型也必须出现在函数参数 t 和 u 之后（右边）。autoT 和 U 对它是可见的，但是函数参数 t 和 u 还不可见，这就是为什么需要 decltype 的原因。（从技术上来讲， decltype(forward(*static_cast(0)) + forward(*static_cast(0))）可以在左边出现，但那看起来会让人不舒服）。

至于在返回语句中还要使用与传给 decltype 的表达式相同的形式，是为了确保在任何情况下都能正确工作。（突击测验：为什么 decltype(t + u) 就不对呢？）。这里的重复是不可避免的，但因为集中-只出现一次且代码位置靠近，所以不会有什么危险。

另一个例子

考虑到例子的完整性，下面是一个 “3种” 不同类型的示例：

C:\Temp>type mult.cpp
#include
#include
#include
#include
#include
#include
using namespace std;

struct Multiplies {
template
auto operator()(T&& t, U&& u) const
-> decltype(forward(t) * forward(u)) {
return forward(t) * forward(u);
}
};

class
public:
explicit
int get() const { return m_n; }
private:
int m_n;
};

class Seconds {
public:
explicit Seconds(const int n) : m_n(n) { }
int get() const { return m_n; }
private:
int m_n;
};

class Joules {
public:
explicit Joules(const int n) : m_n(n) { }
int get() const { return m_n; }
private:
int m_n;
};

Joules operator*(const & w, const Seconds& s) {
return Joules(w.get() * s.get());
}

int main() {
vector<
w.push_back(
w.push_back(
w.push_back(

vector s;
s.push_back(Seconds(5));
s.push_back(Seconds(6));
s.push_back(Seconds(7));

vector j;

transform(w.begin(), w.end(), s.begin(), back_inserter(j), Multiplies());

for_each(j.begin(), j.end(), [](const Joules& r) { cout << r.get() << endl; });
}

C:\Temp>cl /EHsc /nologo /W4 mult.cpp
mult.cpp

C:\Temp>mult
10
18
28

你可能会问“所有的这些处理真的有必要么”，答案是 Yes ，有必要。我已经介绍了完美转发和 decltype 是如何让算术运算函数因子使用起来更容易（不用重复声明元素类型），更灵活（可以混合使用不同的参数和返回类型），更有效率（使用 move 语意）。最重要的是，完美转发和 decltype 让你能够编写更简洁明了的代码，而不灵活和低效的代码不是简洁明了的-这点是我们无法忽视的。

高级规则

decltype 是有一些规则来驱动的。然而，如果你遵照上面的模式就没关系，能正常工作。我很少那样说 C++ ，但是在这里是这样的。

虽然大多数 decltype 应用遵循上面介绍的模式，但 decltype 还可以用于其他环境。在那些情况下，你就用到了 decltype 的高级模式，你应该全面地阅读那些规则，它们在 C++0x 提案 N2857.2 [dcl.type.simple]/4 中被给出。

等等，还有一些要说的

decltype 是第五个且是最后一个添加到VC10中的 C++0x 核心语言特性。虽然VC10 CTP中还没有，但 VC10 Bata 1中会有。而且 VC10 Beta 1 中还有很多 C++0x 标准库特性，我会在后续文章中介绍它们。

Stephan T. Lavavej
Visual C++ Libraries Developer
Published Wednesday, April 22, 2009 10:06 AM by vcblog
翻译：飘飘白云

(转载时请注明作者和出处。未经许可，请勿用于商业用途)

VC10中的C++0x特性 part 2（3）:右值引用

843858859@qq.com(Tomsdinary) — Fri, 20 Nov 2009 12:10:29 GMT

move 语意：可移动成员（movable member)

C++0x 的标准类型（像 vector, string, regex）都有 move 构造函数和 move 赋值函数。而且我们也已经看到了如何在我们自己的类中通过手动管理资源来实现 move 语意（像前面的 remote_integer 类）。如果类中包含可移动数据成员（像 vector, string, regex, remote_integer ）时该怎么办呢？编译器不会自动帮我们自动产生 move 构造函数和 move 赋值函数，所以我们必须手动编写它们。很幸运，有了 std::move() 编写它们是很容易的。

C:\Temp>type point.cpp
#include
#include
#include
using namespace std;

template struct RemoveReference {
typedef T type;
};

template struct RemoveReference {
typedef T type;
};

template struct RemoveReference {
typedef T type;
};

template typename RemoveReference::type&& Move(T&& t) {
return t;
}

class remote_integer {
public:
remote_integer() {
cout << "Default constructor." << endl;

m_p = NULL;
}

explicit remote_integer(const int n) {
cout << "Unary constructor." << endl;

m_p = new int(n);
}

remote_integer(const remote_integer& other) {
cout << "Copy constructor." << endl;

if (other.m_p) {
m_p = new int(*other.m_p);
} else {
m_p = NULL;
}
}

remote_integer(remote_integer&& other) {
cout << "MOVE CONSTRUCTOR." << endl;

m_p = other.m_p;
other.m_p = NULL;
}

remote_integer& operator=(const remote_integer& other) {
cout << "Copy assignment operator." << endl;

if (this != &other) {
delete m_p;

if (other.m_p) {
m_p = new int(*other.m_p);
} else {
m_p = NULL;
}
}

return *this;
}

remote_integer& operator=(remote_integer&& other) {
cout << "MOVE ASSIGNMENT OPERATOR." << endl;

if (this != &other) {
delete m_p;

m_p = other.m_p;
other.m_p = NULL;
}

return *this;
}

~remote_integer() {
cout << "Destructor." << endl;

delete m_p;
}

int get() const {
return m_p ? *m_p : 0;
}

private:
int * m_p;
};

class remote_point {
public:
remote_point(const int x_arg, const int y_arg)
: m_x(x_arg), m_y(y_arg) { }

remote_point(remote_point&& other)
: m_x(Move(other.m_x)),
m_y(Move(other.m_y)) { }

remote_point& operator=(remote_point&& other) {
m_x = Move(other.m_x);
m_y = Move(other.m_y);
return *this;
}

int x() const { return m_x.get(); }
int y() const { return m_y.get(); }

private:
remote_integer m_x;
remote_integer m_y;
};

remote_point five_by_five() {
return remote_point(5, 5);
}

remote_point taxicab(const int n) {
if (n == 0) {
return remote_point(1, 1728);
}

remote_point ret(729, 1000);

return ret;
}

int main() {
remote_point p = taxicab(43112609);

cout << "(" << p.x() << ", " << p.y() << ")" << endl;

p = five_by_five();

cout << "(" << p.x() << ", " << p.y() << ")" << endl;
}

C:\Temp>cl /EHsc /nologo /W4 /O2 point.cpp
point.cpp

C:\Temp>point
Unary constructor.
Unary constructor.
MOVE CONSTRUCTOR.
MOVE CONSTRUCTOR.
Destructor.
Destructor.
(729, 1000)
Unary constructor.
Unary constructor.
MOVE ASSIGNMENT OPERATOR.
MOVE ASSIGNMENT OPERATOR.
Destructor.
Destructor.
(5, 5)
Destructor.
Destructor.

现在你看到啦，按成员移动（memberwise move）是很容易做到的。注意， remote_point 的 move 赋值函数没有进行自我赋值检查，是因为 remote_integer 已经检查过了。也要注意到 remote_point 隐式声明的拷贝构造函数，拷贝赋值函数和析构函数都正常运作。

到现在，你应该对 move 语意已经非常熟悉了。（希望不是抓狂啊！）为了测试你新获得的这个不可思议的技能，请为前面的例子写一个 +() 操作符函数当作练习吧。

最后的提醒：只要你的类支持 move 语意，你就应该实现 move 构造函数和 move 赋值函数。因为不仅仅是你平常使用这些类时可从 move 语意中获利， STL 容器和算法也能从中获利，通过廉价的 move 省下昂贵的拷贝开销。

(转载请注明出处，作者与译者信息，请勿用于商业用途)