应用开发笔记

貌似Java里没有这个概念，默认情况下都是虚函数。

#include 
using namespace std;

class A
{
public:
    int x;
    //虚函数,不加virtual，funA里的a.getX(),即便传入的是B对象，调用的也是A类里的getX(),
    //加了以后，能得到真实的类型，调用的就是B类里的getX()
    virtual int getX()
    {
        return x;
    }
};
class B :virtual public A
{
public:
    int getX()
    {
        return x+1;
    }
};
//把类B的对象作类A的对象处理 
int funA(A &a)
{
    return a.getX();
}

int funB(B &b)
{
    return b.getX();
}
int main()
{
    B b;
    b.x=10;
    //若A类中的getX不是虚函数，下面返回的是10，加了以后，返回的是11
    cout<

假设D类继承了B，C类，B，C类都继续了A类，默认情况下，D类中就有两份A类的成员变量和函数。如果要把他们合二为一，应该把类A定义为虚基类，使用virtual关键字.

#include 
using namespace std;

class A
{
public:
    int x;
};
class B :virtual public A
{
public:
    int y;
};
class C:virtual public A
{
public:
    int y;
};
class D:public B,public C
{

};

int main()
{
    //可以看到，d.B::x，d.C::x,d.x输出是一样的
    D d;
    d.B::x=5;
    cout<

#include 
using namespace std;


class Complex
{
public:
    double real,imag;
public:
    Complex(){
        real=0;
        imag=0;
    }
    Complex(double r,double i)
    {
        real=r;
        imag=i;
    }
    Complex add(Complex & x)
    {
        Complex temp;
        temp.real=real+x.real;
        temp.imag=imag+x.imag;
        return temp;
    }
    Complex* add2(Complex *x)
    {
        Complex *temp=new Complex;
        temp->imag=imag+x->imag;
        temp->real=real+x->real;
        return temp;
    }
    //operator后跟运算符
    Complex operator + (Complex &x)
    {
        Complex temp;
        temp.real=real+x.real;
        temp.imag=imag+x.imag;
        return temp;
    }
};


int main()
{
    Complex a(1,2),b(3,4),c;
    c=a.add(b);
    Complex *d,*e;
    e=new Complex(5,6);
    d=a.add2(e);
    cout<imag<

之所以取不到好友列表，或者取到的列表不全，是因为asmack有个检测机制，判断客户端是否已经有好友列表，具体原理没搞清楚，我的解决办法就是直接注释掉这个方法。 org.jivesoftware.smack.Roster.java: 找到

PacketFilter idFilter = new PacketIDFilter(requestPacketId);
connection.addPacketListener(new RosterResultListener(), idFilter);

注释掉这两行，OK。

原因： AnimationDrawable调用在ImageView完成显示图片之前，所以无法播放动画。 解决方法： 1、手动触发动画 2、添加监听器:

final ImageView voice_icon = (ImageView) view.findViewById(R.id.voice_icon);
                
                voice_icon.getViewTreeObserver().addOnPreDrawListener(new OnPreDrawListener() {
                    
                    @Override
                    public boolean onPreDraw() {
                        // TODO Auto-generated method stub
                        final AnimationDrawable animationDrawable = (AnimationDrawable) voice_icon.getDrawable();
                        if (message.isPlaying()) {
                            animationDrawable.start();
                        }						
                        return true;
                    }
                });

栈，先进后出，后进先出。

#include 
using namespace std;

#define STACK_SIZE 5

struct Stack
{
    int top;
    int buffer[STACK_SIZE];
};
void init(Stack &s)
{
    s.top=-1;
}
bool push(Stack &s,int i)
{
    if(s.top

主要是与Java的区别，相同的就不记了.习惯了Java的语法后，很难找出这些错误… 不需要分号: #define 语句后 #include 语句后 需要分号: 定义完类后,即class的右大括号后 定义完struct后

引用与指针不同在于，引用是直接访问，而指针是间接访问，引用没有自己独立的内存空间，它与被引用的变量共享内存空间，但指针有独立空间。作为函数参数时，引用类型的参数的实参是一个变量，指针类型的参数是变量的地址。从实现角度讲，两者参数传递是一样的。

void swap1(int a,int b)
{
    int t=a;
    a=b;
    b=t;
}
//引用类型交换
void swap2(int &a,int &b)
{
    int t=a;
    a=b;
    b=t;
}

int main()
{
    int a=1,b=2;
    cout<<"a="<

指针函数，可以把一个函数当成变量使，把它传给另一个函数

#include 
using namespace std;

int f1(int x);
int f2(int x);
int sum(int a,int b);
int fun(int(*p)(int),int x);
int main()
{
    //函数指针 返回类型为int ,参数为一个int,可以省略参数名
    int (*p)(int);
    p=f2;
    cout<

下面的代码执行结果是: Animal构造函数 Fish 构造函数 fish eat Fish 析构函数 Animal析构函数 说明：在调用子类的构造函数之前，会先调用父类的构造函数，调用子类的析构函数之后，会调用父类的析构函数。而子类覆写父类的方法，则不会调用父类的方法。

#include 
using namespace std;
class Animal{
public:
    Animal(){cout<<"Animal构造函数"<