#include<iostream>
#include<string>
using namespace std;

// 很奇怪的现象！如果传入参数不是"hello"，是不是不会返回了呢？
// 结果是：返回a！！
string test(string t)
{
    string a="what?";
    if(t=="hello")
    {
        a="world";
        return a;
    }
    // 这里无返回！
}

int main()
{
    string t;
    while(cin>>t)
    {
        cout<<test(t)<<endl;
    }
    return 0;
}               

● java禁止块嵌套变量定义。
● boolean值一定是false或true，不可为1或0。
● 在java中int整型占4个字节，与平台无关，而C++与目标机器和操作系统相关。
● 在java中没有unsigned类型。
● 返回可变对象时，要用到clone技术，该对象要支持clone，实现cloneable接口。
● 每一个类都可以有一个main函数，方便单元测试。
● static数据域用类名访问或static方法，不推荐后者。
● "string"+2结果是"string2"。
● Java中参数传递是值传递，即使是可变对象（值为对象的引用，此时最多改变原参数对象的状态）。
● 类域会自动初始化（0或false或null），而局部变量则不会！
● Java可直接初始化类数据域，C++则不行（有一个初始化列表，在java中没必要，因没有子对象，只有引用）。
● 构造器可调用另一个构造器，而C++不行。
● 目录与包名不一致，可能可以编译，但无法解释运行（找不到class文件）。
● 由于包的可见性，类中的数据一般都应该private。（现在有了包密封jar技术）。
● Java中的继承都是公有继承，并取消多继承（多余的机制）。
● Java子类不可访问超类的私有成员，可用公用接口（super.F()）。
● Java的多态默认处理方式是动态绑定。
● 可将子类放入超类数组，取出时强制转换（先用instanceof检查）（不推荐，可考虑超类的设计）。
● 抽象类不一定包括抽象方法，包括抽象方法的类一定是抽象类。抽象类不能实例化，但可引用其非抽象子类的实例。
● getClass返回一个非空对象的类型名称。
● 定义类时最好重写equals、hashCode、toString方法，必要时加个clone。
● 接口无实例域，只有未实现的方法（默认公有）和常量（默认公有静态final），可继承。
● 内部类可访问外围类实例域，并由编译器为内部类构造器添加外围类引用（outerClassName.this）。
● 局部内部类只可访问final局部变量。
● 静态内部类没有访问外围类的特权。
● AWT将处理用户界面元素的任务交给目标平台本地GUI工具箱，“一次编写，到处运行”，但结果是：1. 外观依赖于平台。2. 可移植库小。 3. “一次编写，到处调试”。
● swing实现所有平台外观一致性、平台相关的bug少、丰富便捷的元素集合。
● 异常处理原则：早传递（throws），晚处理（catch）。不可替代简单测试。无需也无法处理系统error和runtimeerror。

#include<iostream>
#include<time.h>
using namespace std;
const int N=10; // the length of the array will be sorted
int a[N];
int GetRandInt(int min, int max) // min<=x<=max
{
    static bool Init=true;  
    int rc; 
    if(Init)  
    {  
        srand(time(NULL));  
        Init=false;  
    }  
    rc=(rand()%(max-min+1)+min);  
    return rc;  
}
void RandA() // init the array: a
{
    for(int i=0;i<N;i++)
    {
        a[i]=GetRandInt(0,100);
    }
}
inline void Swap(int &a,int &b)
{
    int tmp=a;
    a=b;
    b=tmp;
}
int Partition(int data[],int start,int end)
{
    int i=start;
    int j=end;
    int tmp=data[start];
    while(i<j)
    {
        do{i++;}while(data[i]<tmp);
        do{j--;}while(data[j]>tmp);
        if(i<j) Swap(data[i],data[j]);
    }
    data[start]=data[j];
    data[j]=tmp;
    return j;
}
void QuickSort(int data[],int i,int j)
{
    if(i<j)
    {
        int mid=Partition(data,i,j);
        QuickSort(data,i,mid);
        QuickSort(data,mid+1,j); 
    }
}
void Display(int data[],int n)
{
    for(int i=0;i<n;i++)
    {
        cout<<"a["<<i<<"]="<<data[i]<<endl;
    }
}
int main()
{
    RandA(); // init array: a with random int between 0 to 100
    cout<<"Before sort:"<<endl;
    Display(a,N);
    QuickSort(a,0,N);
    cout<<"After sort:"<<endl;
    Display(a,N);
    cout<<"Successfully end"<<endl;   
    system("pause");
    return 0;
}

转眼之间，暑假已经过去了一半。时间不饶人啊~~得抓紧时间做事情啦！未来就掌握在现在的手中~是成为牛人还是人牛，在此一搏了。

#include<iostream>
#include<time.h>
using namespace std;
const int N=10; // the length of the array will be sorted
const int M=N; // the element in the array range 0 to M-1
int a[N];
int b[N];
int c[M];
int GetRandInt(int min, int max) // min<=x<=max
{
    static bool Init=true;  
    int   rc; 
    if (Init)  
    {  
        srand(time(NULL));  
        Init=false;  
    }  
    rc=(rand()%(max-min+1)+min);  
    return rc;  
}
void RandA() // init the array: a
{
    for(int i=0;i<N;i++)
    {
        a[i]=GetRandInt(0,M-1);
    }
}
void displayA() // display the array: a
{
    for(int i=0;i<N;i++)
    {
        cout<<"a["<<i<<"]="<<a[i]<<endl;
    }
}          
void displayB() // display the array: b
{
    for(int i=0;i<N;i++)
    {
        cout<<"b["<<i<<"]="<<b[i]<<endl;
    }
}
void Jsort()
{   
    for(int i=0;i<M;i++) // init the array: c with 0
    {
        c[i]=0;
    }   
    for(int i=0;i<N;i++) // count the number of elements
    {
        c[a[i]]++;
    }
    for(int i=1;i<M;i++) // count the accumulate number of elements
    {
        c[i]+=c[i-1];
    }
    for(int i=N-1;i>=0;i--) // the purpose of decline is assure stable sort.
    {
        b[c[a[i]]-1]=a[i];
        c[a[i]]--;
    }   
}    
int main()
{
    RandA(); // init array: a with random int between 0 to M-1
    cout<<"before sort:"<<endl;
    displayA();
    Jsort();
    cout<<"After sort:"<<endl;
    displayB();
    cout<<"successfully end"<<endl;   
    system("pause");
    return 0;
}   

全国软件设计师考试的成绩终于出来了~~嗯，考得还可以，上午68分，下午67分，总分就是135了（满分上下午各75，总150分）。这一次的出题的确不难，不少人都过了呢~~ ^^

NetBeans在如果生成项目时发生这种错误就无法生成项目：build-impl.xml:319:class org.netbeans.modules.java.j2seproject.copylibstask.CopyLibs cannot be found
今天在生成项目时就遇到这个问题，郁闷了好久。上网查资料才知道是这么简单的：选择工具(T)---库管理器(L)---CopyLibs任务(类库中)---添加jar/文件夹---%NETBEANS_HOME%\ide7\ant\extra\org-netbeans-modules-java-j2seproject-copylibstask.jar---确定，然后重新生成项目就可以啦！再后来又因为NetBeans的一次意外死掉，重开之后，项目就乱了套。新建了两次项才有点莫名其妙地好了。得到的经验是，NetBeans的更新项目信息速度太慢了，一般来讲都要关了它再重开一次才算是更新，晕晕~~我认为，对文件manifest.mf和build.xml的修改都是在重启NetBeans之后才生效的，不然我不会郁闷这么久，5555555555

项目基本完成了，实现了/、*、-、+、^、sin、cos、tan、cot、abs等功能。不过还要进行Junit测试的最后阶段，然后写实验报告。明天得尽快写好啦，拖拖拉拉的不好~下面是一些截图：

 

大三的考试终于结束了，大学的最后一次必修课考试！这同时也意味着接下来的一大堆事情需要去做了，软件工程大作业，毕业设计，实习，还有个编译原理实验~有点晕呢~

不过至少可以先睡一个好觉了，睡完后再继续加油！年轻人就是这样，脚步一直都是如此地匆忙，一刻也不允许你停顿一下。

这次考试失利，总结一下：

我这次考试失利的个人原因：
1.对于LL(1)和代码优化的复习不充分。
2.对于创新性的题目做得太少了！
3.基本功还不扎实

这次编译原理期末考试不合理的理由：
1.首先当然是试卷印得乱七八糟啦，无语...
2.有些题目比较偏，而且表述有时不清。
3.比较有创新性的题目分值太大了。这对于其它性质的考试不为过，但对于期末考试就不应该这样了，因为考核的应该是基础性的东西比较多才是。李文军这次的出题中的基础题的比重明显比以前出的大大下降了。让人感觉是有意让大批的人不过的。
4.李文军教的班期末考试占50%，我们C班就占60%，所以期末考试难对我们班不利。

偶从总体上概括一下，觉得整本书就讲到了四大块：

一.词法分析

这里要知道，正规文法、有限自动机、正规表达式是可以互相转换的，左右线性文法也可以互相转换，ε-NFA、NFA和DFA也是可以互相转换的。转换的方法大家可以自己总结一下。觉得这里最大的难题是：给出一个具体问题，让你设计对应的DFA之类的。

二.语法分析

这一块好像最多内容了。主要分成两大块，一块是自顶向下的分析方法，一块是自下而上的分析方法。自顶向下的分析方法主要有：递归下降法，包含递归的不带回溯的预测分析方法，非递归的不带回溯的预测分析方法。递归下降法要求文法已消除了左递归，另外两种方法除了要消除左递归之处还要提取公共左因子。自下而上的分析方法主要是要掌握算符优先分析法，以及LR（0）、SLR（即SLR（1））、LR（1）三种分析器。它们都是无回溯的移进归约方法，且对应的文法是无二义性的。其中的最大区别是：LR（0）无展望信息，SLR最多展望一个（当然不是任何时候都展望的，只是发生冲突时才展望，所以才叫“最多”，这也是与LR（1）最大的不同之处），而LR（1）总是向前展望一个字符。

三.语法制导翻译

好像这一章只要会画个带注释的语法树就行了。不知道是不是这样呢？

四.代码优化

好像这一章只要会用DAG对块内局部优化就行了~