#include<stdio.h>

/* Apply the constructor attribute to myStartupFun() so that it

is executed before main() */

void myStartupFun (void) __attribute__ ((constructor));

/* Apply the destructor attribute to myCleanupFun() so that it

is executed after main() */

void myCleanupFun (void) __attribute__ ((destructor));

/* implementation of myStartupFun */

void myStartupFun (void)

{

printf ("startup code before main()\n");

}

/* implementation of myCleanupFun */

void myCleanupFun (void)

{

printf ("cleanup code after main()\n");

}

int main (void)

{

printf ("hello\n");

return 0;

}

Output:

startup code before main()

hello

cleanup code after main()

与上述特性类似，GCC为标准C语言添加了许多其他有趣的特性。

#include <errno.h>

#include <stdio.h>

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

{

    FILE *fp;

    fp = fopen(argv[1], "r");

    if (fp == NULL) {

        fprintf(stderr, "%s\n", strerror(errno));

        return errno;

    }

    printf("file exist\n");

    fclose(fp);

    return 0;

}

上面的程序检查命令行提供的文件是否存在，如果给定的文件存在，则程序将打印“file exists”，否则将打印相应的错误消息。让我们提供一个文件系统中不存在的文件名，并检查x86_64体系结构上程序的输出。

[narendra@/media/partition/GFG]$ ./file_existence hello.c

为什么这个程序崩溃了，相反，它应该显示适当的错误消息。此程序在x86架构上运行良好，但在x86_64架构上会崩溃。让我们看看代码有什么问题。仔细检查程序，我故意没有包括“strerror（）”函数的原型。此函数返回“指向字符的指针”，它将根据传递给此函数的errno打印错误消息。请注意，x86体系结构是一个ILP-32模型，这意味着整数、指针和long都是32位宽的，这就是为什么程序可以在这种体系结构上正常工作的原因。但x86_64是LP-64模型，这意味着长指针和指针都是64位宽。在C语言中，当我们没有提供函数的原型时，编译器假设函数返回一个整数。在我们的示例中，我们没有包含“string.h”头文件（strerror的原型在此文件中声明），这就是为什么编译器假定函数返回整数的原因。但它的返回类型是指向字符的指针。在x86_64中，指针是64位宽，整数是32位宽，这就是为什么从函数返回时，返回的地址会被截断（即32位宽的地址，它是x86_6.4上整数的大小），这是无效的，当我们尝试取消引用此地址时，结果是分段错误。

现在包括“string.h”头文件并检查输出，程序将正常工作。

[narendra@/media/partition/GFG]$ ./file_existence hello.c

没有此类文件或目录

再看一个例子。

#include <stdio.h>

int main(void)

{

    int *p = malloc(sizeof(int));

    if (p == NULL) {

        perror("malloc()");

        return -1;

    }

    *p = 10;

    free(p);

    return 0;

}

在C语言中，如果函数在声明之前被调用，编译器将假定函数的返回类型为int。

例如，以下程序在编译中失败。

#include <stdio.h>

int main(void)

{

    // Note that fun() is not declared

    printf("%c\n", fun());

    return 0;

}

char fun()

{

   return 'G';

}

如果上面代码中的函数char-fun（）稍后被定义为main（）和调用语句，那么它将无法成功编译。因为编译器默认假定返回类型为“int”。在声明时，如果返回类型与int不匹配，则编译器将给出错误。

以下程序编译并运行良好，因为函数是在main（）之前定义的。

#include <stdio.h>

int fun()

{

   return 10;

}

int main(void)

{

    // Note the function fun() is declared

    printf("%d\n", fun());

    return 0;

}

参数呢？编译器不假设参数。因此，当函数应用于某些参数时，编译器将无法对参数类型和arity执行编译时检查。这可能会导致问题。例如，以下程序在GCC中编译良好，并生成垃圾值作为输出。

#include <stdio.h>

int main (void)

{

    printf("%d", sum(10, 5));

    return 0;

}

int sum (int b, int c, int a)

{

    return (a+b+c);

}

存在这样一种误解，即编译器假定输入参数也是int。如果编译器假设输入参数是int，那么上述程序在编译时就会失败。

通常建议在使用函数之前声明函数，这样在程序运行时我们就不会看到任何意外

#include <stdio.h>

fun(int x)

{

    return x*x;

}

int main(void)

{

    printf("%d", fun(10));

    return 0;

}

Output: 100

需要注意的重要一点是，fun（）没有返回类型，程序在大多数C编译器中仍然可以编译并正常运行。在C语言中，如果我们不指定返回类型，编译器会假定隐式返回类型为int。然而，即使返回类型是int，C99标准也不允许省略返回类型。这在旧的C标准C89中是允许的。

在C++中，除了一些像Turbo C++这样的旧C++编译器之外，上述程序是无效的。每个函数都应该在C++中指定返回类型。

当使用exit（0）退出程序时，不会调用本地范围的非静态对象的析构函数。但如果使用了返回值0，则会调用析构函数。

Program 1 – – uses exit(0) to exit

#include<iostream>

#include<stdio.h>

#include<stdlib.h>

using namespace std;

class Test {

public:

  Test() {

    printf("Inside Test's Constructor\n");

  }

  ~Test(){

    printf("Inside Test's Destructor");

    getchar();

  }

};

int main() {

  Test t1;

  // using exit(0) to exit from main

  exit(0);

}

Output:

Inside Test’s Constructor

Program 2 – uses return 0 to exit

#include<iostream>

#include<stdio.h>

#include<stdlib.h>

using namespace std;

class Test {

public:

  Test() {

    printf("Inside Test's Constructor\n");

  }

  ~Test(){

    printf("Inside Test's Destructor");

  }

};

int main() {

  Test t1;

   // using return 0 to exit from main

  return 0;

}

Output:

Inside Test’s Constructor

Inside Test’s Destructor

调用析构函数有时很重要，例如，如果析构函数具有释放资源（如关闭文件）的代码。

请注意，即使我们调用exit（），静态对象也会被清理。例如，请参阅以下程序。

#include<iostream>

#include<stdio.h>

#include<stdlib.h>

using namespace std;

class Test {

public:

  Test() {

    printf("Inside Test's Constructor\n");

  }

  ~Test(){

    printf("Inside Test's Destructor");

    getchar();

  }

};

int main() {

  static Test t1;  // Note that t1 is static

  exit(0);

}

Output:

Inside Test’s Constructor

Inside Test’s Destructor

图1：2021 年 10 月份编程语言排名 TOP 20

TIOBE 是全球最著名的编程语言排行榜，它根据互联网上有经验的程序员、课程和第三方厂商的数量，并使用搜索引擎、Wikipedia、Amazon、YouTube 等统计出排名数据。TIOBE 只是反映某个编程语言的热门程度，并不能说明一门编程语言好不好，或者一门语言所编写的代码数量多少。

TIOBE 排行榜每月更新一次，你可以转到 https://www.tiobe.com/tiobe-index/ 查看编程语言的最新排名。

我一直在负责C语言中文网的一对一答疑工作，有很多同学问我，该如何从这么多编程语言中选择一门适合自己的呢？选择标准又是什么呢？很早我就想写一篇文章来回答这个问题了，现在终于如愿以偿了。



要想选择编程语言，首先得确定开发方向，比如网站开发、APP 开发、机器学习、大数据、嵌入式、GUI 软件、算法设计等。编程语言不是万能的，一门编程语言只能胜任一个或者几个开发方向，一个开发方向往往也有多种编程语言可以选择。



我们首先谈一下开发方向的选择，然后再说编程语言的选择。

1. 选择开发方向

选择大于努力，只有切入一个适合自己的开发方向，才能持续进步。关于开发方向，我有以下两个选择标准。

1) 兴趣

学习编程是一个非常枯燥的过程，内容多，时间长，成本高，就算参加全职培训班，至少也得学习半年才能入门，做出一点小玩意来。要想成为别人眼中的大神，或者编程专家，没有三五年的功夫肯定是不行的。



学习编程的过程是比较艰苦的，没有兴趣很难硬抗下来，即使报名了培训班也学不会，所以，我们首先要选择自己感兴趣的一个开发方向，这样不但能快速学习，以后还能持续进步。



比如我就对网站感兴趣，高中阶段我就想开发一个属于自己的网站，感觉非常炫酷，所以大学我毫不犹豫地选择了网站开发这个方向。我在选择开发方向的时候没有任何纠结，我知道自己必须选择网站开发。



我的大学专业是电子信息工程，跟软件开发几乎没有关系，所以网站开发完全是我自学的，我也是凭借兴趣坚持下来的，一直到现在我还在运营C语言中文网，把兴趣变成了职业。



兴趣是最好的老师，没有之一。遗憾的是，对某个事物有强烈兴趣的人很少，大部分人都是被动选择。



此处我说的兴趣，是指别人无法撼动的热爱，是工作之余让你放松的事情。如果你只是有过某种想法，别人告诉你这个想法不靠谱，你就放弃了，这顶多是一时的鸡血。

2) 未来发展

如果你学习编程不是因为兴趣，只是想选择一份职业，那我希望你切入一个有发展潜力的开发方向。



每个产业的发展规律都是类似的，都要经历以下几个周期：

拓荒期 -> 发展期 -> 成熟期 -> 衰落期

我希望你在发展期切入一个产业，然后持续努力和积累，让产业的发展带着你起飞。站在风口上，猪都能飞起来。



你应该听说过很多没啥背景的人，突然之间一夜暴富了，惹得别人羡慕嫉妒恨吧，这些人，大都是在一个爆发式增长的行业里面翻了身，比如十年前的包工头、持续火热的程序员。

注意，最好不要在拓荒期切入一个产业，你很有可能坚持不到曙光到来之时就已经转行或者年老色衰了，成为了别人谈笑中的“烈士”。

对于软件开发产业来说，GUI 桌面软件已经是过去式了，APP 和网站也已经进入成熟期，我推荐机器学习（人工智能）和大数据两个方向，它们都是国家重点扶植的细分产业，而且写入了十四五规划，未来至少还有十年的发展时间。



机器学习需要大数据提供原料，反过来，大数据分析也依赖机器学习模型，它们是相辅相成的，很难隔离开。



以上是我基于 10 年的编程经验和 7 年的创业过程给出的建议，如果你觉得不对，就当做耳旁风吧，毕竟我也才三十出头，阅历还不是很丰富，难免有偏颇。



另外，选择产业方向也是有风险的，也是一次命运赌博，谁也不能确定这个产业能不能发展起来，就算发展起来，又需要多少年呢？又有多大的产值呢？



比如人们一直谈论的人工智能已经发展了几十年了，到现在还是“人工智障”，底层理论并没有本质的突破。虽然国家把人工智能选为重点产业，注入了海量资金和人才，各家大公司也跟风进入，但是底层理论如果不突破，十年以后没准还是智障，只不过应用场景多了。谁也不能穿越到未来，谁也不能告诉你确定的答案。



就算一个国家，也会点错科技树，比如：

• 美国认为自己无人能敌，发展了朱姆沃尔特级驱逐舰，打算近岸攻击，想不到中国突然崛起，海军开始下饺子，美国不得不转为远洋作战，废掉朱姆沃尔特级。
• 日本押宝混动汽车和氢能汽车，积累了大量专利，但是中国却切换了赛道，倾力发展纯电动汽车，并且积累了一定的优势，日本想逆袭非常困难，汽车产业岌岌可危。

在产业发展过程中，会有很多不确定因素，我们只能尽力选择一个有前景的产业。



其实吧，很多“暴发户”也不懂得什么产业发展规律，他们只是阴差阳错地进入了某个产业，恰好赶上产业崛起而已。我自己当初也不懂互联网，只是对网站感兴趣，就进入了互联网产业，抓住了 PC 互联网的尾巴，所有才比其他行业的同学混得好点。



也就是说，我混的好，不是因为我足够优秀，而是因为我进入了互联网产业，搭上了产业的便车，我只是比我的同学更加幸运而已。

2. 选择编程语言

确定了开发方向，接下来就可以选择编程语言了。有的开发方向比较纯粹，只有一两种编程语言，有的开发方向鱼龙混杂，有五六种编程语言，选择编程语言也是一个让人纠结的过程。



以下是部分开发方向可以选择的编程语言：

1) GUI 桌面软件

能开发 GUI 软件的编程语言众多，既有传统的 C++、C#、VB、Delphi、Java，也有新晋选手 Python、Node.js（JavaScript），还有小众的易语言（中文编程语言）。



如果你只是想玩玩，那么你随意，适合自己的就行，其中 Python 上手比较简单。



如果你想找一份工作，建议学习 C++ 或者 C#。C# 虽然比 C++ 简单一点，但是它只适用于 Windows 平台；而 C++ 是一种通用语言，它可以应用于 Windows、Linux 以及嵌入式平台，就业选择较多。

2) 网站开发

网站开发分为前端和后台，前端就是用户在浏览器中看到的界面，后台就是放在服务器上的程序。



前端开发需要学习 HTML、CSS 和 JavaScript，没得选，而且必须都学习。



后台发开语言则多如牛毛，有走进坟墓的 ASP、Ruby on Rails，也有常用的 PHP、Java（JSP）、C#（ASP.NET），还有新晋选手 Python、Node.js（JavaScript）、Go 语言。



如果你想自己玩玩或者创业，建议选择 PHP，上手非常简单。我使用的也是 PHP，因为当时学不会 ASP.NET 和 JSP，所以选择了简单的 PHP。



如果你想找一份工作，那么已经走近坟墓的 ASP、Ruby on Rails 就不要选了，没人用了。C# 也不要选了，只适用于 Windows 平台，而大量的服务器都是 Linux。Python 也不要选，实际应用场景不多。Go 语言主要用作 Web 底层开发，而不是应用层开发。



剩下的 PHP、Java、Node.js 你自己看着办吧，没法说哪种语言一定有优势，它们只是适用于不同的场景。



值得一提的是，这里我们将 Node.js 和 JavaScript 看做是等价的，如果你选择了 JavaScript，那么你既能开发网站前端，也能开发网站后台，就不用学习多种编程语言了。

3) APP 开发

这个开发方向比较简单，Android APP 开发使用 Java 或者 Kotlin，iOS APP 开发使用 Objective-C 或者 Swift。



每种操作系统都有两种编程语言，一种是传统的，一种是新晋的，选择好了操作系统，把两种语言都学了吧。

4) 嵌入式开发

一般使用汇编、C语言和 C++，近年来也有开发板支持 JavaScript 和 Python。



自己玩的话，可以选择 Python，上手简单。



想找工作的话，还是走传统路线吧，把汇编、C语言和 C++ 都学了吧。



只有那些有 Web 开发基础的程序员才会选择 JavaScript。

5) 机器学习

这是一个比较综合的开发方向，初学者一般从 Python、MATLAB 开始搭建模型，实际工程应用中可能需要使用 C++、Java 等其它语言去实现。



Python 是必学的，MATLAB 最好也要掌握，C++ 和 Java 视情况而定。

6) 大数据

这也是一个比较综合的开发方向，相关语言有 Python、R语言、Java、Scala。把 Python 和R语言学习一下，剩下的看情况吧。

由于我的能力所限，我无法对所有开发方向做深入的分析，有说的不到位的地方，请大家留言，或者在公众号聊天框中反馈给我。

以上说的仅仅是编程语言，除了编程语言，大家还需要学习某些框架或者库，比如：

• Java 网站开发需要掌握 Servlet、JSP 技术，以及 Spring、Spring MVC、Spring Boot、Spring Cloud、Mybatis、Hibernate 框架；
• Python 机器学习需要掌握 PyTorch、TensorFlow、Caffe 等框架，以及 sklearn、NumPy 等模块。

除了编程语言和框架/库，你当然还要掌握一两种数据库，常用的有 MySQL、Oracle、MongoDB、Redis、Sqlite 等，这里不再展开讨论。

总结

软件开发是一个大产业，其中有很多细分方向，每个方向使用的技术栈都不一样，而且要经过长期学习才能掌握，所以大部分程序员都只擅长某个开发方向，那些多面手，要么是学艺不精，要么是技术大咖。



人们之所以迷茫，就是不知道如何选择，这篇文章虽然不一定能让你做出最终的决定，但是可以给你一种不同的视角和标准，帮助你打开思路。

来源：http://c.biancheng.net/view/9435.html

大家好，今天要给大家分享的是任何一门语言都要学习的东东语法（大牛请忽略这篇文章）。那么php的语法是什么样的呢？为了给大家讲解以及自己巩固。我将php5与最新的php7的语法做了些整理。同时这里再推荐看下 php基础-设计模式，及 php 一步步实现mvc架构——路由篇

一 关于变量

php5和7并无区别

变量以非特殊字符，数字开头

错误的命名方式：$^&%name,$123name

正确的命名方式：$name123,$_Name123

二 关于include,require

大家都知道，在php5中include在碰到 程序上的错误的话，会发出警告，并继续执行。而require会终止程序继续执行。那么在php7中是如何处理的呢？

先看一个include 的例子

=====================

b.php

<?php

if(1==2)

{

continue;

}

?>
=====================

a.php

<?php

include("b.php");//b.php先执行

echo "hello"

?>

php5

结果： 输出 "hello"

php7

结果： 输出 PHP Fatal error: Cannot break/continue 1 level in b.php on line….

注意：

在脚本中那个continue,php5处理时会判断1==2是true还是false,如果是false,则直接绕过，php7中，不管1==2是否成立，它会预先判断continue是否符合语法规则。

结论：对于include,reuqire php5 不会预判不符合语法规则，只有执行到了才会返回错误，而php7会预判语法规则

三 关于数组

php7中define 一个常量数组

<?php

define("a",[12,23,33]);

var_dump(a);

php5

结果：输出

Use of undefined constant a – assumed 'a' in /var/www/html/array.php on line 3 string(1) "a"

php7

结果：输出

array(3) {

[0]=>

int(12)

[1]=>

int(23)

[2]=>

int(33)

}

结论: define 在php5中不可定义为数组在php7中可定义为数组

php7中的变量运行方式与php5有所区别

<?php

class Test {

function a()

{

print_r("hello");

}

}

$obj = new Test();

$arr = ["a"];

$obj->$arr[0]();

php5

结果 输出:

hello

php7

结果输出：

PHP Fatal error: Uncaught Error: Function name must be a string in /var/www/html/array.php:13

注意:

php7 要 运行的话需要将 $obj->$arr[0]() 改成这样 $obj->{$arr[0]}()。

如此一来php5 和php7都能运行这段代码。

结论：

php7代码运行的结合方式与php5中不同，要运行的话需要用{}显示的处理变量结合顺序

四 关于类型
php本来就是弱类型语言，在php7之前除了class以外是 没有这个要求的，那么在php7以前要在函数或方法声明变量类型该如何做呢？我先举个多态的例子

例子

<?php

interface Human {

function getSex();

}

class Woman implements Human{

function __construct()

{

}

function getSex()

{

return "I am woman";

}

}

class Man implements Human {

function __construct()

{

}

function getSex()

{

return "I am man";

}

}

class Call {

function catlog(Human $p)

{

return $p->getSex();

}

}

$obj = new Call();

var_dump($obj->catlog(new Woman()));

var_dump($obj->catlog(new Man()));

php5和php7输出结果一样:

string(10) "I am woman"

string(8) "I am man"

注意：

Man 和Woman 都实现了Human接口，所以它们都是Human类型，即多态。Human $p 这个$p就是Human类型。

在php7中可以给变量及返回值声明类型

标量类型声明

<?php

function test(int $a)

{

return $a;

}

var_dump(test(1));

php5 输出结果：

PHP Catchable fatal error: Argument 1 passed to test() must be an instance of int, integer given, called in /var/www/html/type.php on line 7 and defined in /var/www/html/type.php on line 2

php7输出结果：

int(1)

注意: test(int $a) 这个$a 之前的int 就是类型声明

结论:

php7支持 标量类型声明，php7以下不支持

返回值类型声明

<?php

function test(int $a): array

{

return [$a];

}

var_dump(test(1));

php7输出：array(1) {[0]=>int(1)}

注意：函数返回的结果类型要与声明的类型一致 否则将报错 。例如将return [$a] 改成 return $a,将报错

PHP Fatal error: Uncaught TypeError: Return value of test() must be of the type array, integer returned in ….

关于太空符号

<?php

var_dump("a"<=>"a","a"<=> "b","b"<=> "a")

php5 结果 输出：

PHP Parse error: syntax error, unexpected '>' in

php7 结果 输出：

int(0)

int(-1)

int(1)

注意：php7以前不支持太空符操作，

结论：左边比右边小 则输出 -1，比右边大 就输出1 相等就输出0

关于php7 和PHP5的特性今天就先总结到这。下一篇讲php的设计模式，欢迎大家继续关注，谢谢

来源：https://zhuanlan.zhihu.com/p/349220668

#include <stdio.h>
int main() {
    printf("hello, worldn");
    return 0;
}

#include<stdio.h>

printf("hello,worldn");

#include<stdio.h>
int main(){
    printf("hello,");
    printf("world");
    printf("n");
    return 0;
}

事实上，因特网邮件(STD 11, RFC 822)http://ietfreport.isoc.org/idref/rfc822/目前所支持的仅仅是7-bit的ASCII字符集。MIME(RFC 2045到2049)http://ietfreport.isoc.org/idref/rfc2045/扩展了网络邮件以支持不同的媒体类型和字符集，也因此能够在邮件信息里支持Unicode了。虽然它确实提供了随着时间而增加的字符集注册的方法，但MIME既没有把Unicode定义为容许的字符集，也没有说明它要怎么编码。

本文档描述了一种Unicode的转换编码，它只使用7-bit的ASCII字节，并且意图在文件由US-ASCII表中字符组成的限定条件下，对人来说是易读的。还说明了在MIME的内容中怎么使用这种转换编码(RFC 1641“在MIME中使用 Unicode”)http://ietfreport.isoc.org/idref/rfc1641/。

起因

虽然存在着其他的Unicode转换格式，并且也足以在这样的环境下使用(最明显的就是UTF-8，还有UTF-2 or UTF-FSS)，但他们都有一个缺点，就是他们使用了128-255这一范围对Unicode编码，超过了US-ASCII的范围。因此，在邮件环境中，8位字节必须要被编码。这要求让文本经历两次连续的编码，让US-ASCII范围以外的字符有一个显著的扩展，这使得非英文的使用者处于非常不利的地步。例如，使用UTF-8和MIME中的Quoted-Printable内容编码方式一起处理，让US-ASCII字符出现在一个字节里，但其 它的字符可能需要9个字节。

概述

UTF-7把Unicode字符编码为US-ASCII的字节，并且用替换序列编码超出范围(0-127)的字符。为了这个目的，US-ASCII 表里的一个字符就要保留作为替换字符使用。大多邮件网关和系统不能处理完整的US-ASCII字符集(例如那些基于EBCDIC的)，所以UTF-7包含了在US-ASCII用于编码的预留，以便所有的邮件系统都能兼容。UTF-7应该一般用在7-bit传输的环境中，比如邮件。其他的环境中Unicode或者UTF-8还是首选的。参见RFC 1641，http://ietfreport.isoc.org/idref/rfc1641/“在MIME中使用Unicode”整体描述了在MIME中Unicode转换编码的使用。

定义

首先，定义Unicode：

16-bit字符集，Unicode，由"Unicode标准，2.0版本"所定义。这套字符集与国际标准组织的编码ISO/IEC 10646-1一致。 编码后形式为UCS-2；子集为300；实现等级为3，包含对10646+的前7个修正。

注：Unicode 2.0 还进一步说明了这些字符在ISO标准组织以外的使用和交互。事实上，一个有效的10646序列就是一个有效的Unicode序列，反之也是；Unicode 协会提供对序列的解析，而ISO标准组织却一直没有。

然后，定义一些US-ASCII字符子集：

集合D：(直接字符)包含如下的字符(取自RFC 1521，http://ietfreport.isoc.org/idref/rfc1521/附录B，在RFC 2045 http://ietfreport.isoc.org/idref/rfc2045/中不再出现了)：

大写字母A-Z，小写字母a-z，和10个数字0-9，和后面的9个特殊字符(注意："+"和"-"遗漏了)

字符 ASCII & Unicode值 (十进制) '' 39 ( 40 ) 41 , 44 – 45 . 46 / 47 : 58 ? 63

集合O： (可选的直接字符) 包含如下的字符： (注意 "" 和 "~" 遗漏了)：

字符 ASCII & Unicode值 (十进制) ! 33 " 34 # 35 $ 36 % 37 & 38 * 42 ; 59 < 60 = 61 > 62 @ 64 [ 91 ] 93 ^ 94 _ 95 '' 96 { 123 | 124 } 125

基本原理：有两个字符 "" 和 "~" 被遗漏了是因为在ASCII表中他们经常被重新定义变量值。

集合B： (更改过的Base64) (RFC 2045 http://ietfreport.isoc.org/idref/rfc2045/)定义的Base64字母表中的字符，除了衬垫字符："=" (十进制值为 61)。

基本原理： 衬垫字符 "=" 被排除了是因为UTF-7被设计用来在报头字段中使用，就如RFC 2047 http://ietfreport.isoc.org/idref/rfc2047/中的集合4。 因为RFC 2047编码中唯一易读的编码就是"Q"，(基于RFC 2045''s Quoted Printable)，所以"="不适合使用(没有很多的转义序列)。这很不幸，但是却不可避免。其实，"=" 字符在UTF-7中也可以作为转义字符使用，如果不是使用"+"。

注：所有US-ASCII在Unicode中都是用同样的值，补0扩展到16 bits。

UTF-7 定义：

一个UTF-7流用如下方式使用7-bit US-ASCII字节表示16-bit Unicode字符：

规则1：(直接编码) 上面的集合D中的Unicode字符可以直接的编码为ASCII的等价物。集合O中的字符可以有随意的直接编码为ASCII的等价物，但要记得其中的很多的字符在报头字段是不合法的，或者不能正确的穿过邮件网关；

规则2：(Unicode替换编码) 通过在前面加上转换字符"+"(US-ASCII字符十进制值为43)，任何一个Unicode序列都可以使用集合B中的字符编码。"+"意味着后面的字节将被作为更改过的BASE64字母表中的元素解析，直到遇到一个不是字母表中的字符为止。这些字符中包含控制字符，比如回车和换行；因此，一个Unicode转换序列总是在一行上结束。作为一个特殊的情形，如果序列结束于一个"-"字符(US-ASCII值45)，那么那个字符就要被关注；其他的结束字符不用关心，而且可以正常处理；

注意：如果跟在转换字符后的第一个字符就是"-"，那么一个多余的必须被加上，以便结束转换序列，所以真正的"-"不是它关心的；

基本原理：一个结束字符在如下的情形是必须的：在更改的base64序列的下一个字符是集合B中的部分，或者本身就是一个结束字符。通过界定编码的序列也可以增强可读性。作为特定情形，序列"+-"可以用来编码字符"+"。一个"+"字符之后立即跟着的字符若不是集合B的成员或者"-"，就是一个形式有误的序列；

对Unicode使用更改的base64编码时候，可以首先转换Unicode的16bit的数量值为一个字节流。通过把成对中的一个当作单独的值以后，就会转换为字节对。奇数个字节的的文本是错误的形式，ISO1646 字符超过可设定地址范围的部分转换为字节对后也无法编码。

基本原理：ISO/IEC 10646-1:1993(E)说明了当UCS2形式被字节流序列化时，哪个字节在前面。选定一种用来发送的规范格式，在一般网络应用中也是遵循的；

基本原理：ISO 10646和Unicode标准中代码点定位的策略是一个同步一致的字符表。如果字节对超过了ISO10646可寻址范围，就无法对代码点定
位了。

然后，对字节流进行编码时使用了"更改的base64编码"算法(定义于RFC 2045)，更改中去掉了衬垫字符"="。在编码时候，增加了代替的"0 bits"以便衬垫base64编码字符的边界。在解码时，在"更改的base64编码"序列最后的一些bits，如果不能组成一个完整的 16-bit的Unicode字符，那么就会被丢弃。如果丢弃的bits不是0，那么这个编码序列就是有格式错误的。

基本原理：在对更改的 Base64 进行编码时，不使用衬垫字符"="，因为就象上文提及的，它与在 RFC 2047 http://ietfreport.isoc.org/idref/rfc2047/中将它用做 "Q 内容传输编码" 的转义字符相冲突；

规则3： 空格 (十进制 32)，tab (十进制 9)，回车(十进制 13)，和换行(十进制 10)字符可以直接使用ASCII等价字符表示。事实上，应该注意到MIME传输编码也有使用这些字符的规则。如果使用并不遵循RFC 822的限制，必须要使用MIME编码而不是7bit或者8bit的一些编码，比如quoted-printable，binary，或者base64。

鉴于给定的一组规则，Unicode字符可以经由规则1或者规则3编码，一个字符占用一字节；然后其他的Unicode字符用规则2编码，一个字符占用平均(2 + 2/3)个字节，加上一个转换开关字节用来进入"更改的base64编码"，加一个可选的转换跳出字节。

例如：Unicode序列 "A ." (十进制： 0041,2262,0391,002E) 可以被编码如下：

A+ImIDkQ.

例如：Unicode序列 "Hi Mom – -!" (十进制： 0048, 0069, 0020, 004D, 006F, 006D, 0020, 002D, 263A,002D, 0021) 可以被编码如下：

Hi Mom -+Jjo–!

例如：Unicode序列 用汉语表示日文 "nihongo" (十进制： 65E5,672C,8A9E) 可以被编码如下：

+ZeVnLIqe-

在MIME中使用UTF-7字符集

UTF-7字符集对邮件传输是安全的，因此可以应用于MIME中任何内容的编码(除非出现了对行长度和行中断的强制约束)。特定的，7-bit的编码用于主体， "Q内容编码"用于报头的情况也可以使用。MIME字符集的标签是UTF-7，这一点对大于等于2.0版本的Unicode很重要。

例子：这是一个MIME消息的片段，包含了一段Unicode序列：

"Hi Mom !" (十进制 0048,0069, 0020, 004D, 006F, 006D, 0020, 263A, 0021)。  Content-Type: text/plain; charset=UTF-7 Hi Mom +Jjo-!

例子：这是一个MIME消息的片段，包含了一段用汉语表示日语词 "nihongo" 的 Unicode 序列：

(十进制： 65E5, 672C, 8A9E)。 Content-Type: text/plain; charset=UTF-7 +ZeVnLIqe-

例子： 这是一个MIME消息的片段 ，包含了一段Unicode序列：

"A ." (十进制： 0041, 2262, 0391, 002E) Content-Type: text/plain; charset=utf-7 A+ImIDkQ.

例子： 这是一个MIME消息的片段，包含了一段Unicode序列：

"Item 3 is 1." (十进制 0049, 0074, 0065, 006D, 0020, 0033, 0020, 0069, 0073, 0020, 00A3, 0031, 002E)。 Content-Type: text/plain; charset=UTF-7 Item 3 is +AKM-1.

注意：为了和"可能不支持Unicode与MIME的系统"达到最好的互用性，在准备邮件传输正文的时候，"行中断"应该遵守网络惯例。这意味着行应该很短而且要使用SMTP的CRLF来标记结束。Unicode的行分隔符(十进制 2028)和段分隔符 (十进制 2029)应该被替换为SMTP的行中断。理想的情况，这应该由一个理解 Unicode的用户代理透明的处理。

这样的准备也不是绝对必要的，因为UTF-7和适当的MIME编码可以在不遵守网络惯例的情况下处理正文，但是对于没有Unicode或者MIME的系统的可读性就会被削弱了。关于邮件协同工作能力问题的讨论可以参见 RFC 2045。

在UTF-7转换序列中行是不可以被打断的，因为这样的序列不可以跨越行中断。因此，UTF-7编码可以放在行中断后面。如果一行含有转换后会很长的序列，可以使用MIME中的编码来处理正文，比如 Quoted Printable。另一个可行性就是同时执行行中断和UTF-7编码，这样包含转换序列的行就已经符合长度限制了。

讨论

在本节中，我们将引入UTF-7编码，它反对选择现有的Unicode转换编码(例如UTF-8)和MIME编码一起使用。在讨论之前，有必要先列举一些假设，这些假设有关于典型自然语言文本串中字符出现的频率，而这些频率可以用来评估典型存储的需求：

1. 多数西欧语言使用大概7/8的US-ASCII字符和1/8的打丁字符(ISO-8859-1)；

2. 多数基于非罗马字母表的语言(比如希腊)使用大约1/6的ASCII字符(因为空格 也算是7bit的)，其他的来源于他他们自己的字母表；

3. 东亚基于表意字表的语言(包括日文)基本使用他们自己的字符表，Han或者CJK；

4. 非直接编码的标点字符的出现次数不足以影响结果；

注意：当前的8bit标准，比如ISO-8859-x，要求使用内容传输编码。为了和后续的讨论对比，把代价列举如下，(注意：很多其中的数字只是接近的，因为他们依赖文本确切的组成形式)：

Base64中的8859-x 文本类型

平均字节数/字符

所有 1.33 Quoted Printable中的8859-x文本类型

平均字节数/字符 US-ASCII 1 西欧 1.25 其他 2.67

注意：使用base64编码的Unicode平均一个字符占用了2.67个字节。为了对比，我们看一下UTF-8和UTF-7在Base64和Quoted中的情况。还要指出的是：一个较长的字符串有固定的经常性开销，大约为 1/n，n是指编码后字节串的长度。

UTF-8在 Base64中 文本类型 平均字节数/字符 US-ASCII 1.33 西欧 1.5 一些字母表的 2.44 其他 4 UTF-8在Quoted Printable中 文本类型 平均字节数/字符 US-ASCII 1 西欧 1.63 一些字母表的 5.17 其他 7-9 UTF-7 文本类型 平均字节数/字符 多数 US-ASCII 1 西欧 1.5 其他 2.67+2/n

我们会发现UTF-8在Quoted Printable选项中是不可行的，因为在文本中有太多的除了西欧语言外的其他的语言。当只有当文本中大多是ASCII或者拉丁数字字符，偶尔有其他的字符散布的时候，这样编码才是可行的。我们将首选介绍一种编码能很好的适用于所有用户。我们还会发现UTF-8与base64编码的使用者中，有大量的非西欧用户。即便是里面有很多的ASCII字符，因为没有很好的可读性，这样的编码也不是十分适用。基于UTF-7的编码可以给出很好的结果，并且对ASCII文本有很好的可读性。

UTF-7 给出的结果挑战了ISO-8859-x，而且适用于所有的Unicode字符。我想，这证明了引入一种新的Unicode转换编码是正确。

UTF-7作为一种可选的方案，但是，因为multipart/mixed内容类型忽略了行中断的问题，也可能在使用现有的MIME机制的时候会和其他的Unicode字符集产生混乱。(感谢Nathaniel Borenstein提了这个建议)，例如：(重新说一下前面的例子)

理论上，这里去掉了在消息体里对UTF-7的需求。(多部分类型不可以在报头字段里使用)事实上，我们发现使用Unicode字符集变得更为广泛了，间断使用一些特殊的Unicode字符(例如钱和数学符号)的情况会出现，并且文本里还会包含很多小块的其他的语句，比如西里尔的，希腊的和东亚的语言。(罗马的文字都已经能被MIME字符集充分处理了)虽然多部分技术对于大块用于交互的文本来说工作的很好，我们还是觉得它不能充分的支持刚刚讨论的应用类型，所以我们认为引入UTF-7是合理的。

总结

UTF-7编码方式使得Unicode字符集能在US-ASCII的7-bit范围中编码。对于一些Unicode序列，如果含有相对较长的US-ASCII字符串，中间夹杂了单个的Unicode字符或者Unicode串，这种编码是高效的。因为它容许没有Unicode支持的系统直接阅读US-ASCII的部分。UTF-7仅仅应该用在7-bit传输的时候，比如邮件。在其他的环境下，Unicode 或者UTF-8应该是首选的。

致谢

对如下人的贡献，评论和建议表示感谢，如果因为疏忽而遗漏了某一位，也不是故意的！

附录 A —— 例子：

这里有个更大的例子，是从一个BIG5编码的文档里拿来的。只是精简了一些。这里有两个版本，第一个使用了可选的"O"字符集(这可能会造成不能通过一些邮件网关)，第二个没有。

下面就是全都是中文的一端节选 (+itaKng-)。原文是这样的：

(中文文本做了英文翻译)分别做了个BIG5和GB两个版本：

本文中没有包含BIG5或者GB的所有字符。缺失的字符已经使用它们的Unicode/ISO代码点指示出来了。"U+-" 后面跟着四个十六进制指定一个Unicode/10646代码(例如：U+-9F08)。这对小规模的BIG5和GB使用的问题，不是一个好的解决方案；但是这种解决方案的表现，对我个人而言是很满意的。

下面就是全都是中文的一端节选(+itaKng-)。原文是这样的：

(中文文本做了英文转换)分别做了个BIG5和GB两个版本：

本文中没有包含BIG5或者GB的所有字符。缺失的字符已经使用它们的Unicode/ISO代码点指示出来了。+ACI-U+-+ACI- 后面跟着四个十六进制指定一个Unicode/10646代码(例如：U+-9F08)。这对小规模的BIG5和GB(+ADs-)使用的问题，不是一个好的解决方案；但是这种解决方案的表现，对我个人而言是很满意的。

对安全的考虑

本文没有讨论安全问题。

参考

[UNICODE 2.0] "The Unicode Standard, Version 2.0", The Unicode

Consortium, Addison-Wesley, 1996. ISBN 0-201-48345-9.

[ISO 10646] ISO/IEC 10646-1:1993(E) Information Technology–Universal

Multiple-octet Coded Character Set (UCS). See also

amendments 1 through 7, plus editorial corrections.

[RFC-1641] Goldsmith, D., and M. Davis, "Using Unicode with MIME",

RFC 1641, http://ietfreport.isoc.org/idref/rfc1641/ Taligent, Inc., July 1994.

[US-ASCII] Coded Character Set–7-bit American Standard Code for

Information Interchange, ANSI X3.4-1986.

[ISO-8859] Information Processing — 8-bit Single-Byte Coded Graphic

Character Sets — Part 1: Latin Alphabet No. 1, ISO

8859-1:1987. Part 2: Latin alphabet No. 2, ISO 8859-2,

1987. Part 3: Latin alphabet No. 3, ISO 8859-3, 1988.

Part 4: Latin alphabet No. 4, ISO 8859-4, 1988. Part 5:

Latin/Cyrillic alphabet, ISO 8859-5, 1988. Part 6:

Latin/Arabic alphabet, ISO 8859-6, 1987. Part 7:

Latin/Greek alphabet, ISO 8859-7, 1987. Part 8:

Latin/Hebrew alphabet, ISO 8859-8, 1988. Part 9: Latin

alphabet No. 5, ISO 8859-9, 1990.

[RFC822] Crocker, D., "Standard for the Format of ARPA Internet

Text Messages", STD 11, RFC 822, UDEL, August 1982.

[MIME] Borenstein N., N. Freed, K. Moore, J. Klensin, and J.

Postel, "MIME (Multipurpose Internet Mail Extensions)

Parts One through Five", RFC 2045, 2046, 2047, 2048, and
2049, November 1996.

作者的地址

David Goldsmith

Apple Computer, Inc.

2 Infinite Loop, MS: 302-2IS

Cupertino, CA 95014

Phone: 408-974-1957

Fax: 408-862-4566

EMail: goldsmith@apple.com

Mark Davis

Taligent, Inc.

10201 N. DeAnza Blvd.

Cupertino, CA 95014-2233

Phone: 408-777-5116

Fax: 408-777-5081

EMail: mark_davis@taligent.com

结束语

翻译有不准确的地方还望见谅！

1.下载并安装交叉编译器。

      我用的编译器是arm-linux-gcc4.3.2，在友善之臂的网站下的。

只要解压一下就OK。

      tar -zxvf arm-linux-gcc-4.3.2.tgz

 得到文件夹usr,把里面的arm目录复制到:

   sudo mv usr/local/arm /usr/local

 接下来只要设置好环境变量，就可以使用了，环境变量可以设置成全局的，也可以设置为当前终端可用，方法是:

      export PATH=$PATH:/usr/local/arm/4.3.2/bin

 然后运行: arm-linux-gcc -v 可以看到版本信息。

 交叉编译器的使用方法和gcc一样。

2.安装串口通信工具：minicom

      不管怎样，minicom都是一款经典实用的串口通信工具，安装如下：

      sudo apt-get install minicom

配置:

      sudo minicom -s

      选择Serial port setup，配置端口（配置随开发板和串口连接方式改变），我的配置如下：

      配置好了后回车，选择Save setup as dfl，回车保存

      使用：接好线以后，在终端输入minicom就可以打开串口了。

3.安装nfs（网络文件系统）

      装这个是为了方便调试，不需要每次都把程序下载到开发板。

安装：sudo apt-get install nfs-kernel-server

配置hosts.deny:（禁止连接，权限小于允许连接）

sudo gedit /etc/hosts.deny

修改如下：

           portmap:ALL

           lockd:ALL

           mountd:ALL

           rquotad:ALL

           statd:ALL

      配置hosts.allow:（允许连接）

sudo gedit /etc/hosts.allow

修改如下：（设置192.168.1网段的主机可以访问）

                 portmap: 192.168.1.*

                 lockd: 192.168.1.*

                 rquotad: 192.168.1.*

                 mountd: 192.168.1.*

                 statd: 192.168.1.*

注意，配置好hosts.deny和hosts.allow后，要重启portmap daemon服务：sudo service portmap restart

      配置NFS挂载权限：sudo gedit /etc/exports

           我设置成根目录共享：/ 192.168.1.*(rw,sync,no_root_squash)

      然后重启NFS：

sudo service nfs-kernel-server restart

      这样，NFS就安装好了。

      用网线将PC和开发板连接好，设置主机的IP：ifconfig eth0 192.168.1.26

      设置开发板的IP（首先进入linux）：ifconfig eth0 192.168.1.11

      然后可以ping一下，看PC和开发板是否连通了。

      没有问题的话，就可以mount了。

      启动minicom,给开发板上电,进入linux,回车激活终端.

      输入:mount -o nolock 192.168.1.26:/ /mnt

      如果没有出错，就把PC的根目录mount到开发板的/mnt目录下了。

FROM:http://blog.csdn.net/crazyman2010/article/details/6081855

这个确实是单件模式了，但是它没有解决单例的生命周期问题，new出来的内存没有delete掉，那么这个对象的生命到底什么时候结束呢？

答案不是确定的，在不同的操作系统平台上又不同的情况。Unix下是进程消失时内存释放。



我们来解决这个问题，给它加一个清理器。嘿嘿！~~

为了更加通用，我打算用模板来实现，请看代码：

 

那么我们来使用一下：

这样解决了单件模式自动释放的问题。

原理是什么呢？

在instance中，static Cleaner clr;这个声明，由于是静态成员，系统会在栈里分配内存，回收工作也就由系统自动完成了。



有时候我们要考虑单件在整个软件系统中的释放顺序，因此，

如果您还有兴趣，我们可以看一下这个单例的释放究竟是在什么时候：

根据在MAC下的控制台的输出结果：

int main()
{
    char    url[256];
    printf("http://");
    scanf("%s", url);
    geturl(url);
    return 0;
} 

上网搜了一些关于这方面的资料，发现有一些是用C++或java等语言写的，当然也可以直接下载开源的代码，也可以下载库文件直接使用。但考虑到对xml文件解析其实用不到那么多功能，也考虑到硬件方面无法支持这么大的库文件。因此，决定自己写一段代码用于解析简单的xml文件。

看了一些源代码，发现他们主要使用树型结构来实现对xml 的解析，由于能力有限吧，感觉很麻烦，可能占用内存也会很大，所以我苦苦思索了好久，决定使用递归的方法解析xml文件，每当解析出相应的数值时，可以立即对这些数值进行判定是否合法，如果合法的话，可以继续解析；如果不合法的话，就可以直接跳出。

对这个xml文件，我做了很严格的定义：

<!– 注释–>

<主标签 属性值1>

<子标签> 属性值2 </子标签>

<子标签>

<下级子标签>属性值3</下级子标签>

</子标签>

</主标签>

在这里，可以在标签间的任何地方进行注释，但禁止在标签内部进行注释；标签可以有多层嵌套，但必须保证标签有结束标志，嵌套必须合法。

属性值的规定方面，可以正确的解析属性值2和属性值3，但不会解析属性值1，属性值1可以起到注释的作用。

下面贴出一些主要的代码：

首先读取xml文件：

 fp = fopen("update.xml","r");
 if(fp == NULL) return 0;
 while((c = getc(fp)) != EOF)
 {
  data[i++] = c;
 }
然后对data数组进行相应的处理，如下：

int xml_takecell(char *data, int start, int end, char *name)
{
 int flag = 0;
 int j = 0;
 int nowstart = 0;
 int nowend = 0;
 char value[45] = {0};
 int keywords = 0;
 int isok = 0;

 if(update == 1) return 1;

 nowstart = xml_getnamestart(data,start,end,name);
 nowend = xml_getnameend(data,nowstart,end,name); 
 keywords = iskeywords(name);
 
 switch(keywords)
 {
 case KEY_UPDATELIST:
  xml_getvalue(data,nowstart,nowend,value);
  node_name = keywords;
  flag = 0;
  break;
 case KEY_ENABLE:
  xml_getvalue(data,nowstart,nowend,value);
  flag = 0;
  break;
 case KEY_START:
  xml_getvalue(data,nowstart,nowend,value);
  flag = 0;
  break;
 case KEY_END:
  xml_getvalue(data,nowstart,nowend,value);
  flag = 0;
  break;
 case KEY_ID:
  node_name = keywords;
  flag = 1;
  break;
 case KEY_SWVERSION:
  node_name = keywords;
  flag = 1;
  break;
 case KEY_CONFIG:
  node_name = keywords;
  flag = 1;
  break;

  ……
 default:
  flag = 1;
  node_name = 0;
  break;
 } 

 isok = checkupdate(node_name,keywords,value);
 if(isok == 1) return 0;

 if(flag == 1 && nowend <end)
 {
  cleanstring(name, 15);
  xml_takecell(data,nowstart,nowend,name);
 }
 if(nowend <end) 
 {
  cleanstring(name, 15);
  xml_takecell(data,nowend,end,name); 
 }

 return 0;
}

这是实现递归的核心代码，其中，函数xml_getnamestart()、xml_getnameend()是对同一个标签的开始处和结尾处进行查询，返回值是所在数组的位置，然后可以在此标签内部进行递归查询，直到找到最低一级的标签，并利用 xml_getvalue()获取标签的属性值。函数checkupdate()是对获取的属性值合法性做判断，如果是非法的，可以直接跳出此次处理。KEY_UPDATELIST、KEY_SWVERSION这些是自己事先定义的标签名。

各函数如下：

函数xml_getnamestart：

int xml_getnamestart(char *data, int start, int end, char *name)
{
 int now = start;
 int i = 0;
 int flag = 0;

 while(now < end)
 {
  now++;
 /*在这里，可以忽略<!–注释 –>形式的注释*/ 

 if(data[now-1] == '<' && data[now] != '!' && data[now] != '/')
   flag = 1; 
  else if((data[now] == '>' || data[now] == ' ') && flag == 1)
  {
   flag = 0;
//   printf("xml_getnamestart—->name is %s now is %dn",name,now);
   break;
  }
  if(flag == 1)
  {
   name[i] = data[now];
   i++;
  }

 }
 return now;
}

函数xml_getnameend：

int xml_getnameend(char *data, int start, int end, char *name)
{
 int now = start;
 int i = 0;
 int flag = 0;
 char value[15] = {0};
 int ok = 0;

 while(now < end)
 {
  now++;
  if(data[now-1] == '<' && data[now] == '/')
  {
   flag = 1; 
   i = 0;
   ok = 0;
   now++;  
  }
 /*这里表示标签以空格或>结尾，也解释了属性值1为什么不能解析*/

 else if((data[now] == '>' || data[now] == ' ') && flag == 1)
  {
   flag = 0;
  }
  if(flag == 1)
  {
   if(name[i] == data[now])
   {
    i++;
    ok++; 
   }
   else if(name[i] != data[now])
   {
    i = 0;
    ok = 0;
    flag = 0;
   }
   
  }
  
  if(ok == strlen(name)) break;
 }
// printf("xml_getnameend—->name is %s now is %d n",name,now);
 return now;
}

函数xml_getvalue：

/*在 > 和 < 之间为属性值*/

int xml_getvalue(char *data, int start, int end, char *value)
{
 int i = 0;
// char value[45] = {0};
 cleanstring(value,45);
 if(data[i+start] == '>') start++;
 for(i = 0; i+start< end; i++)
 {
  if(data[i+start] == '<') break;
  value[i] = data[start+i]; 
 }

 return 0;
}

这些代码写的比较业余，以后还要多多锻炼一下代码的编写规范。

这些参考资料是利用树型结构解析xml文件的思想，现在看的不是很明白，供以后修炼：

http://dangle2046.blog.163.com/blog/static/832104472008929101736243/

http://www.oschina.net/p/mini-xml

FROM:http://blog.csdn.net/xiaosong521/article/details/7410451

这个技术在重视时间的应用中也很有用。在预先分配的内存缓冲构造一个对象是一种“时间常量”操作，之所以这样说是因为程序分配操作本身不会浪费宝贵的时间。同时也要注意当系统没有足够的内存时，动态内存分配可能失败。因此，对于重视任务的应用，预先分配一个足够大的缓冲有时是不可避免的。

许多应用需要在给定的时间构造不同类型的对象。想一想这样一个例子，一个GUI应用根据用户的输入，每次、显示不同的对话框，利用重复分配和释放内存，这个应用能提前创建一个内存缓冲，并能在这个缓冲里反复构造和销毁不同类型的对象。
C++提供了几种特点来方便实现在预先决定的内存位置构造一个对象的任务。在这些特点中，包括一个特殊形式的new操作符，叫做“定位new”（placement new）操作，以及一个显式的析构处理。实现方法如下：

第一步：分配一个足够的内存缓冲区，以便存放给定类型的对象。如果想要每次构造不同类型的对象，需要至少以最大的对象所占空间的大小分配一个缓冲。预分配的缓冲是在可用内存空间中分配的纯字符数组。

一旦分配了缓冲，就能在缓冲中构造每一种类型的对象。为此，使用特殊版本的new操作符（“定位new”），以缓冲地址为placement new的参数。为了使用placement new，必须包含标准头文件。下面的代码片断中，使用placement new操作在内存地址buff上构造类型为Foo的对象。

Placement new 以先前分配的缓冲（buff）地址作为参数，并在这个缓冲上构造给定类型的对象。他返回构造对象的指针，这个对象指针的使用与通常的指针使用没什么两样。

当不再需要这个对象的时候，必须显式调用其析构函数释放空间。做这件事是有一些技巧的，因为许多人错误地假设对象会被自动销毁，错也！。在预分配的缓冲里构造另一个对象之前或者在释放缓冲之前，如果忘了显式调用析构函数，程序将产生不可预料的后果。显式的析构器声明如下：

换句话说，一个显式的析构器与普通的成员函数调用一样，只是名字与普通的成员函数稍有差别。一旦对象被销毁，便可以在预分配的内存中再次构造另一个对象。实际上，这个过程可以无限制地重复：构造一个对象，销毁它，然后又反复利用预分配的缓冲构造新对象。

当不再需要预定义的缓冲时，或者说当应用程序关闭时，必须释放预定义的缓冲。使用delete[]完成这个任务，因为预定义的缓冲是一个字符数组。下列代码包含一个完整的例子的所有步骤，包括最终缓冲的释放：