这样就行了,在重新启动,是不是面板都恢复成默认的啦。

如果还不行,那就

rm -rf .gconfd

1、不小心误删面板的恢复方式
 
Linux代码  收藏代码

    gconftool --recursive-unset /apps/panel 
     rm -rf ~/.gconf/apps/panel 
    pkill gnome-panel 

2、不小心更改默认主题风格的恢复方式
Linux代码  收藏代码

    rm -rf /home/你自己的用户目录/.gconf* 
     sudo reboot now 

解决方法：   

（1）使用gedit的打开菜单，在选择文件的同时，可以有选项选择编码，这样可以保证打开的文件编码正确，正确显示文件中的中文，只对此次有效
  

（2） 如果经常使用gbk的编码，那么就可以通过终端下面执行gconf-editor,然后选在apps下gedit-2下preferences下的encodings下的auto_detected,双击，添加gbk编码，同时gbk编码移动到utf-8的后面，这个细节也很重要。否则有时候还是会检测成其他编码。出现乱码。
    

     推荐第二种方法，治本之选。

此文章的主旨是希望过于专注.NET程序员在做好工作、写好.NET程序的同时，能分拨出一点时间接触一下.NET之外的东西（例如10%-20%的时间），而不是鼓动大家什么都去学最后什么都学不精，更不是说.NET不行或劝大家放弃.NET。恕我愚钝，此主旨在文中表达不够清楚，看评论中很多朋友误解了，特此说明。

另外，本文中的观点并不全部是我个人的想法，相当一部分来自我以前聊过天的某些大牛，他们很多来自微软、百度、腾讯等知名企业，并且很多已经成为技术骨干，我曾经从他们那里受益匪浅，于是我把他们的指教结合自身的经验和理解写成此文。这就是此文的来源。

------------------------------------------------------------华丽的分割线------------------------------------------------------------

在给这篇文章起标题的时候，我斟酌了很久，因为我个人是反对使用“.NET程序员”、“C++程序员”或“PHP程序员”这类简单粗暴的方式为程序员做划分的。但是客观确实存在一个现象，就是很多程序员会为自己设置一个无形的界限，将自己与某种语言或平台硬绑定到一起，例如我这里所指的“.NET程序员”。请注意这与“术业有专攻”是不同概念的，有自己专攻的平台或领域这很正常，但是有很多人偏执地将自己与某个语言或平台紧紧捆绑，而忘记了自己首先是一名程序员，然后才使用某种语言，他们偏执于平台并陶醉于自己建立的盒子里，而不愿主动去接触一些盒子外的事物，最终使得自己无法进步。

从我个人的观点看，本文中“.NET程序员”是指具有如下特点的程序员群体：

• 学习、工作的技术范围均局限于.NET平台及衍生，对.NET之外的技术没有主动接触或学习的欲望。
• 不断学习各种.NET平台上的库或框架，如ADO.NET，ASP.NET MVC，WPF，Silverlight，WCF，WP，EF，NHibernate……
• 工作无法脱离Visual Studio，习惯于图形化的工作环境。
• 时常抱怨微软的技术更新太快，微软开发平台包办太多以至于自己身价贬值。
• 对面向对象、设计模式、软件架构等东西具有极大的热情，宁可花大量时间编造各种“设计模式小故事”也不愿花点时间了解一点新鲜的东西（如Unix下的IPC）。
• 对Java颇有微词，觉得C我根本用不到，至于PHP？它能做到的.NET都能做到，认为用Linux的大多在装逼，而Lisp、Lua、Eiffel神马的都是浮云，我管它们干什么。
• 认为面向对象语言就是程序设计语言的代名词，命令式编程深入骨髓，不太了解函数式语言或契约式语言是什么。
• 用.NET很多年了，但感觉自己没什么突破，没什么进步，成天就搞些增删改查的劳什子。
• 经常讨论或思考.NET或Java或C或其它语言哪个好，搞哪个更挣钱这种问题。

如果您有超过3项符合上述特征，我想我们可以聊一聊，因为据我的观察，感觉博客园上这类朋友还是挺多的。

希望我能做到旁观者清

有一个事实我想先和大家澄清一下，其实.NET只是我的业余爱好。由于博客园主要偏重于.NET平台，且园子里的朋友对面向对象、架构之类的颇感兴趣，所以我写了很多关于.NET及架构方面的文章（如果您注意观察，会发现我博客里这类文章正减少并趋于消失），其实相对于设计、架构这类东西，我个人更感兴趣的是具体的科学与技术，例如各种编程语言的原理、应用及实现扩展，操作系统原理，网络编程，通信协议，算法与数据结构，数据挖掘，机器学习，分布式等等；语言方面我比较喜欢的是PHP、Python、Lisp等；而编程方面我更推崇Unix下的编程哲学和编程方法；我爱vim胜过VS无数倍。

因此，.NET和C#我一直是作为业余爱好来发展的，希望这没有让任何人觉得沮丧。很多朋友加我QQ或MSN问我关于.NET的问题，我经常答不上来，很多人或许觉得我不近人情，但我其实是真的答不上来。例如我在博客中写过一系列关于ASP.NET MVC的文章，很多人是冲那系列文章加我的，但是其实ASP.NET MVC我只在beta版时摆弄过两个星期，然后就再也没有碰过，所以后来很多朋友问我想关问题我是真的答不上来。

所以，在博客园这个以.NET和架构之类为主的社区，我算是半个旁观者吧，我看到园子里很多朋友都把自己禁锢在自己创造的盒子里，所以我希望以旁观者的身份，给这些朋友提几个建议。

每半年接触并学习一门语言

有许多人通常觉得只要把一门语言学会学精就行，这个想法我觉得对了一半。一个程序员应该有一门精通的语言，但是还要不断学习新的语言（当然不能太频繁），倒不是为了以防哪天万一用到这门语言，而是接触学习不同的语言会拓展程序员的视野。

如果你一直用C#，试试Lisp，你会惊叹于还有这样写程序的方式，嗯？看来我得去学学Lamda演算；试试Python，你会惊讶于还有如此小巧优美的东西；试试Lua，你会发现原来语言还能嵌入其它语言，要不要为WOW写个外挂试试？试试Eiffel，你会发现还有契约式编程这种方法，嗯？什么？Java上有iContract，那我要不要为.NET实现一个？随着这种学习过程，你的思维自然就被拓展开了，而不是满脑子的Class、 Object、MVC、OO……

其实学习语言不一定是学习没听说过的，许多您听到耳朵长茧却从来没有深入学习的“老朋友”，如C、PHP，如果您细心学下来，也会得到许多意外的收获。

例如在学C的过程中，你会发现不可能脱离Unix环境而把C学好，你会接触POSIX和System V，你会主动深入学习进程、线程、信号、I/O、IPC，你会接触TCP/IP协议。你会发现要学好C还要理解计算机组成原理，你还会发现原来还有大小端这个东西。

深入学习PHP，你会发现PHP远不仅仅是一个做Web的脚本语言那么简单，你会了解到它SAPI、PHP Compiler和Zend Engine的优美结构，你会发现有opcode，你会发现PHP浑身都是扩展点，你可以扩展功能，扩展Compiler和Zend Engine，甚至可以完全实现自己的编译和运行逻辑。你会了解APC是如何缓存opcode，APD是如何跟踪PHP的运行。

每次学习一门语言，你会发现这不是一门语言，而是一个崭新的新大陆，里面有太多让人兴奋和新奇的东西，而如果你执意禁锢在“.NET盒子”里，你就永远不会知道这些。

主动突破自己 接受更多挑战

如果什么东西都是用到才学，代码都是有用才写，那我只能非常抱歉的说你还不是个程序员，而只是个代码工人。程序员应该有主动出击的意识，应该对自己未接触的领域有无限向往。幸运的是，互联网上的财富实在太多了，你应该尽其所能去接触学习未知的东西，而不要总想我学习这个东西能不能换来钱给孩子买尿布和奶粉。你可以有很多借口，但是我想说，借口想找总是有的，时间想找也总是有的，还是看自己到底要什么。不要一边躺在盒子里一边又抱怨自己没有进步。

例如Google Publication，这里有世界最优秀的Google工程师们理论和实践的总结，来读读这些伟大的论文吧，看看这个伟大的公司和一群伟大的人都干了些什么，了解一下Map Reduce是怎么回事，如果了解了你自然想去试试Hadoop，还有Bigtable和GFS，哦！太震撼了，原来存储数据也有这么多讲究，不是放硬盘里或通过Insert插入数据库就行了。也许这些英文论文读起来很困难，但是我想一周一篇的要求并不高（我现在仍然保持着一周读两篇论文的习惯）。要知道，最新、最严谨的东西都在论文里，如果你只是通过书本或社区学习，那么你永远不会知道今天在计算机科学与技术的领域又发生了哪些令人震撼的事情，出现了哪些新奇的东西。

不要太懒惰，你写增删改查写累了吗？Come on！有没有想过自己写一个小型的httpd？当然你需要先去学习HTTP协议（rfc2612），试试能不能写一个PHP的SAPI扩展令你的httpd处理PHP脚本。有没有想过自己用lex和yacc实现一个自己的小语言，也不是完全没用，也许你已经对你的领域业务逻辑烂熟于胸，那么去实现一个自己的领域语言吧。啊！我要去学习编译原理、形式语言与自动机……咦，这东西还挺有意思的，去看看计算理论去……如果到了这里，你已经开始接触计算机的数学本质了，而你的层次将会得到升华。

学习就是这样，主动突破自己，给自己一些挑战性的任务，生活才有趣。成天困在.NET的盒子里，我们还有脸称自己为程序员吗？

脱离IDE 玩玩纯文本与shell

从没用过IDE的程序员可能是悲剧，但从没脱离过IDE的程序员绝对是悲剧！

你有没有觉得自己越来越不像个“编程序”的而越来越像“堆程序”的。好的，即使在工作时你离不开IDE，那么业余时间让你的IDE滚蛋，等等，你改用Notepad？气死我了你！试试vim或Emacs，体验一下用纯文本写程序，用gcc编译连接的乐趣。你会发现“yyp”比“选中一行，Ctrl+C，点击下一行起始位置，Ctrl+V”简单的多，你会发现按一下“0”比按20次“左箭头”省事的多。等源程序多了，也许你会想去学习Makefile的写法。你会莫名其妙地发现自己更懂编译和连接过程了。

相信我，用纯文本和shell写程序比用IDE酷多了，想吸引女孩子吗？你去问问你们班或你们公司最漂亮的女生，她也会这么想。重要的是，这种酷不是“装B”的酷，而是有效率的酷。什么？你已经受不了IDE了……

接受更多的编程哲学与学习方式

注意我是用的“接受”而不是用“改变”，你不需要改变什么，写.NET程序很好，不过你可以适当吸取一下其它领域的编程哲学与学习方式。可以说Windows（特别是.NET）程序员和Unix程序员思考问题的方式大不相同，如果现在需要一辆汽车，Windows程序员会建立一个从冶铁到装配的“All in one”汽车制造基地；而Unix程序员会去分别建立采矿场、冶铁厂、设计公司、材料制造厂、机械制造厂和装配厂。我不想讨论他们各自的优缺点（因为很容易陷入无谓的宗教纷争），但是对于你来说，了解一些其它的编程哲学对你没有坏处。

另外就是学习方式，例如你要学习PHP，请千万不要去书店购买各种《21天精通PHP》或《PHP编程宝典》，你应该首先打开Google，找到 PHP官网，然后去官方文档哪里寻找学习资源。网上还有各种wiki，mailing lists和社区，请不要放弃这些资源。然后同时你可以去Amazon看书评，然后小心而谨慎地选择一本相关的书籍（影印版最优，翻译版其次）。

一个人想突破自己不容易，关键在于自己有没有突破的意愿。衷心希望有一天，您的脑中不再被ASP.NET，ASP.NET MVC，WCF，WPF，ADO.NET，Silverlight，EF……而占满，如果到了那一天，你会发现，咦？！我.NET的水平也大幅提升了！

方法一，递归

int findOneinBin(int n)
{
   if(n<2)
      return 1;
  else return n%2+findOneinBin(n/2);
}

这个方法很容易想到，如果是奇数的话就是他的n/2+1，也就是有一位加上1个1.

方法二，google一下找出来的，没看懂

#define POW(c) (1<<(c))
#define MASK(c) (((unsigned long)-1) / (POW(POW(c)) + 1))
#define ROUND(n, c) (((n) & MASK(c)) + ((n) >> POW(c) & MASK(c)))

int bit_count(unsigned int n)
{
    n = ROUND(n, 0);
    n = ROUND(n, 1);
    n = ROUND(n, 2);
    n = ROUND(n, 3);
    n = ROUND(n, 4);
    return n;
}

一下子看不明白，先把宏展开来：
POW是计算2的幂
MASK很奇怪，一个全1的无符号数字除以2的幂的幂加1？
好在打印出来还能看得懂：

MASK(0) = 55555555 h = 01010101010101010101010101010101 b
MASK(1) = 33333333 h = 00110011001100110011001100110011 b
MASK(2) = 0f0f0f0f h = 00001111000011110000111100001111 b
MASK(3) = 00ff00ff h = 00000000111111110000000011111111 b
MASK(4) = 0000ffff h = 00000000000000001111111111111111 b

这些mask分别把32位数字划分为几个部分。每个部分的前一半和后一半分别是全'0'和全'1'。
MASK(0)分为16个部分，MASK(1)分为8个部分，...
ROUND中对n的处理：(n & MASK) + (n >> POW & MASK)
POW的值刚好是MASK中连续'0'(或者连续'1')的长度。也就是说ROUND把由MASK分开的n的各个部分中的高POW位和低POW位相加。
为了便于说明，取一个简单的部分：MASK(1)的0011
假设n的值为1001，那么ROUND后的结果就是10 + 01 = 11 b，把这个结果赋值给n，这时n的含义由原来的二进制位串变为'1'位的数量。特别的，当ROUND(n, 0)时，把n当作一个32个部分各自'1'位的数量。（'0'表示没有'1'，而'1'则表示有1个'1'）
计算完n = ROUND(n, 0)后，n是一个16个部分各自'1'位数量的'数组'，这个'数组'的每个元素只有2个二进制位。最大值为2，足够由2个二进制位来表示。
接下来，计算完n=ROUND(n,1)后，n是一个8个部分各自'1'位数量的'数组'，这个'数组'的每个元素只有4个二进制位。最大值为4，足够由4个二进制位来表示。（实际只需要3个二进制位）
...
最后一步，计算n=ROUND(n,4)后，n是一个1个部分各自'1'位数量的'数组'，这个'数组'的每个元素有32个二进制位。最大值为32，足够由32个二进制位来表示。（实际只需要6个二进制位）
这个代表32位内'1'位数量的32位二进制数也就是我们要求的结果。

一

第一最好不相见，如此便可不相恋。
第二最好不相知，如此便可不相思。
第三最好不相伴，如此便可不相欠。
第四最好不相惜，如此便可不相忆。
第五最好不相爱，如此便可不相弃。
第六最好不相对，如此便可不相会。
第七最好不相误，如此便可不相负。
第八最好不相许，如此便可不相续。
第九最好不相依，如此便可不相偎。
第十最好不相遇，如此便可不相聚。
但曾相见便相知，相见何如不见时。
安得与君相诀绝，免教生死作相思。

二

你见，或者不见我
我就在那里
不悲不喜
你念，或者不念我
情就在那里
不来不去
你爱，或者不爱我
爱就在那里
不增不减
你跟，或者不跟我
我的手就在你手里
不舍不弃
来我的怀里
或者
让我住进你的心里
默然　相爱
寂静　欢喜

三

住进布达拉宫，
我是雪域最大的王。
流浪在拉萨街头，
我是世间最美的情郎。
我问佛：为何不给所有女子羞花闭月的容颜？
佛曰：那只是昙花的一现，用来蒙蔽世俗的眼
我问佛：世间为何有那么多遗憾？
佛曰：这是一个婆娑世界，婆娑即遗憾
我问佛：如何让人们的心不再感到孤单？
佛曰：每一颗心生来就是孤单而残缺的
我问佛：如果遇到了可以爱的人，却又怕不能把握该怎么办？
佛曰：留人间多少爱，迎浮世千重变
我问佛：如何才能如你般睿智？
佛曰：佛是过来人，人是未来佛
我问佛：为什么总是在我悲伤的时候下雪
佛说：冬天就要过去，留点记忆
我问佛:为什么每次下雪都是我不在意的夜晚
佛说:不经意的时候人们总会错过很多真正的美丽
我问佛:那过几天还下不下雪
佛说:不要只盯着这个季节，错过了今冬

    结构体还是有很多的区别。

    1.类成员默认访问权限为私有（private），结构体成员默认访问权限为公共（public）；

    2.从class继承默认是private继承，而从struct继承默认是public继承。

注意：C中的struct跟C++中struct可是不一样的

*共用体 构造数据类型,也叫联合体
用途：使几个不同类型的变量共占一段内存(相互覆盖)
结构体是一种构造数据类型
用途：把不同类型的数据组合成一个整体-------自定义数据类型
---------------------------------------------------------------
结构体变量所占内存长度是各成员占的内存长度的总和。
共同体变量所占内存长度是各最长的成员占的内存长度。
共同体每次只能存放哪个的一种！！
共同体变量中起作用的成员是尊后一次存放的成员，
在存入新的成员后原有的成员失去了作用！
---------------------------------------------------------------
struct 与 union主要有以下区别:
1. struct和union都是由多个不同的数据类型成员组成, 但在任何同一时刻, union中只存放了一个被选中的成员, 而struct的所有成员都存在。在struct中，各成员都占有自己的内存空间，它们是同时存在的。一个struct变量的总长度等于所有成员长度之和。在Union中，所有成员不能同时占用它的内存空间，它们不能同时存在。Union变量的长度等于最长的成员的长度。
2. 对于union的不同成员赋值, 将会对其它成员重写, 原来成员的值就不存在了, 而对于struct的不同成员赋值是互不影响的。

引用：就是变量或对象的别名，它不是值，不占存储空间，其只有声明没有定义，其主要用于函数的形参和函数的返回值。

注意：引用作为函数的返回值，大多数情况下可以被指针代替，但是遇到构造函数和操作符重载函数的“形式自然”的问题是，是不能被替代的。

引用和指针区别：

1. 引用必须初始化，但是不分配存储空间。指针不声明时初始化，在初始化的时候需要分配存储空间。
2. 引用初始化以后不能被改变，指针可以改变所指的对象。
3. 不存在指向空值的引用，但是存在指向空值的指针。

实例分析：

int a=0;            //全局区初始化区
char *p1;    //全局区未初始化区
static char b;      //全局区未初始化静态变量

int main()
{
    int c;                     //栈区临时变量
    char s[]="abc";            //栈区临时数组变量
    char *p2;                  //栈区临时指针变量
    char *p3="123";    //常量区常量，栈区指针变量
    static int d=0;            //全局初始化区静态变量
    p1=new char[10];           //堆区分配10个字符空间
    p2=new char[20];           //堆区分配20个字符空间
    strcpy(p1,"123");          //"123"放在常量区，编译器有可能将它与p3所指向的区域相同
}

内存分配方式：

    来自：百度百科

    函数指针是指向函数的指针变量。 因而“函数指针”本身首先应是指针变量，只不过该指针变量指向函数。这正如用指针变量可指向整型变量、字符型、数组一样，这里是指向函数。如前所述，C在编译时，每一个函数都有一个入口地址，该入口地址就是函数指针所指向的地址。有了指向函数的指针变量后，可用该指针变量调用函数，就如同用指针变量可引用其他类型变量一样，在这些概念上是一致的。函数指针有两个用途：调用函数和做函数的参数。

  1. 函数指针声明方法：

【数据类型】【*】【指针变量名】（形参列表）；

  注1：“函数类型”说明函数的返回类型，由于“()”的优先级高于“*”,所以指针变量名外的括号必不可少，后面的“形参列表”表示指针变量指向的函数所带的参数列表。例如：

    int func(int x); /* 声明一个函数 */

　　int (*f) (int x); /* 声明一个函数指针 */

　　f=func; /* 将func函数的首地址赋给指针f */

　　赋值时函数func不带括号，也不带参数，由于func代表函数的首地址，因此经过赋值以后，指针f就指向函数func(x)的代码的首地址。

  注2：函数括号中的形参可有可无，视情况而定。

　　下面的程序说明了函数指针调用函数的方法：

#include <iostream>
using namespace std;
int max(int x,int y){return (x>y?x:y);}
int main()
{
    int (*ptr)(int,int );
    int a,b,c;
    ptr=max;
    cin>>a>>b;
    c=(*ptr)(a,b);
    cout<<c<<endl;
    return 0;
}

    ptr是指向函数的指针变量，所以可把函数max()赋给ptr作为ptr的值，即把max()的入口地址赋给ptr,以后就可以用ptr来调用该函数，实际上ptr和max都指向同一个入口地址，不同就是ptr是一个指针变量，不像函数名称那样是死的，它可以指向任何函数，就看你想怎么做了。在程序中把哪个函数的地址赋给它，它就指向哪个函数。而后用指针变量调用它，因此可以先后指向不同的函数。不过注意，指向函数的指针变量没有++和--运算，用时要小心。

2.指针函数和函数指针的区别：

1,这两个概念都是简称，指针函数是指带指针的函数，即本质是一个函数。我们知道函数都又有返回类型（如果不返回值，则为无值型），只不过指针函数返回类型是某一类型的指针。

　　其定义格式如下所示：

　　【返回类型标识符】【 *】【返回名称】（形式参数表）

　　{ 函数体 }

　　返回类型可以是任何基本类型和复合类型。返回指针的函数的用途十分广泛。事实上，每一个函数，即使它不带有返回某种类型的指针，它本身都有一个入口地址，该地址相当于一个指针。比如函数返回一个整型值，实际上也相当于返回一个指针变量的值，不过这时的变量是函数本身而已，而整个函数相当于一个“变量”。

3.关于函数指针数组的定义

关于函数指针数组的定义方法，有两种：一种是标准的方法；一种是蒙骗法。

　　第一种，标准方法：

　 函数指针数组是一个其元素是函数指针的数组。那么也就是说，此数据结构是一个数组，且其元素是一个指向函数入口地址的指针。

　　根据分析：首先说明是一个数组：数组名[]

　　其次，要说明其元素的数据类型指针:*数组名[].

　　再次，要明确这每一个数组元素是指向函数入口地址的指针：函数返回值类型 (*数组名[])().请注意，这里为什么要把“*数组名[]”用括号扩起来呢？因为圆括号和数组说明符的优先级是等同的，如果不用圆括号把指针数组说明表达式扩起来，根据圆括号和方括号的结合方向，那么 *数组名[]() 说明的是什么呢？是元素返回值类型为指针的函数数组。有这样的函数数祖吗？不知道。所以必须括起来，以保证数组的每一个元素是指针。

　　第二种，蒙骗法：

　　尽管函数不是变量，但它在内存中仍有其物理地址，该地址能够赋给指针变量。获取函数地址的方法是：用不带有括号和参数的函数名得到。

　　函数名相当于一个指向其函数入口指针常量。 那么既然函数名是一个指针常量，那么就可以对其进行一些相应的处理，如强制类型转换。

　　那么我们就可以把这个地址放在一个整形指针数组中，然后作为函数指针调用即可。

　　完整例子：

#include <iostream>
int add1(int a1,int b1);
int add2(int a2,int b2);

int main()
{
    int numa1=1,numb1=2;
    int numa2=2,numb2=3;
    int (*op[2])(int a,int b);
    op[0]=add1;
    op[1]=add2;
    printf("%d ,%d\n",op[0](numa1,numb1),op[1](numa2,numb2));

    system("PAUSE");
    return 0;
}

int add1(int a1,int b1)
{
    return a1+b1;
}
int add2(int a2,int b2)
{
    return a2+b2;
}

#include<iostream>
using namespace std;
int main()
{
    char str1[]="abc";
    char str2[]="abc";

    const char str3[]="abc";
    const char str4[]="abc";

    const char *str5="abc";
    const char *str6="abc";

    char *str7="abc";
    char *str8="abc";

    cout<<(str1==str2)<<endl;
    cout<<(str3==str4)<<endl;
    cout<<(str5==str6)<<endl;
    cout<<(str7==str8)<<endl;
    getchar();
}

结果是：

为神马呢？

写个代码来看看内存地址：

#include<iostream>
using namespace std;
int main()
{
    char str1[]="abc";
    char str2[]="abc";

    const char str3[]="abc";
    const char str4[]="abc";

    const char *str5="abc";
    const char *str6="abc";

    char *str7="abc";
    char *str8="abc";

    printf("abc:  %d\n",&("abc"));
    printf("str1:  %d\n",str1);
    printf("str2:  %d\n",str2);
    printf("str3:  %d\n",str3);
    printf("str4:  %d\n",str4);
    printf("str5:  %d\n",str5);
    printf("str6:  %d\n",str6);
    printf("str7:  %d\n",str7);
    printf("str8:  %d\n",str8);
    getchar();
    return 0;
}

结果是：

分析：

str1，str2，str3，str4是数组变量，它们有各自的空间，而数组名就是数组的首地址。

str5，str6，str7，str8是指针，它们指向了相同的常量区域。