基础语言知识C++

强制转换：

（Cplusplus基础与提高（何桂林）21页）

static_cast：有隐式转换的

格式：

static_cast<目标类型> (标识符)

int a = 10;
int b = 3;
cout<<static_cast<float>(a)/b<<endl; //float = int int = float
return 0;

int *p; void *q;
p = static_cast<int*>(q)

reinterpret_cast：没有隐式转换的

格式：

reinterpret_cast<目标类型> (标识符)

举例：

int main()
{
　　int x = 0x12345648;
　　char *p = reinterpret_cast<char*>(&x);
　　//char*p = static_cast<char*>(&x);
　　printf("%x\n",*p);
　　int a[5] = {1,2,3,4,5};
　　int *q = reinterpret_cast<int*>((reinterpret_cast<int>(a) +1));
　　printf("%x\n",*q);
　　return 0;
}

const_cast：脱常量的

格式：

const_cast<目标类型> (标识符) //目标类类型只能是指针或引用。

举例：

#include <iostream>
using namespace std;
void func(int & ref) //别人己经写好的程序或类库
{
    cout<<ref<<endl;
}
int main(void)
{
    const int m = 4444;
    func(const_cast<int&>(m));
    return 0;
}

dynamic_cast（这个不需要）

容器：

Vector<String8> args; （容器）：

深入解析C++ STL中的常用容器

异常：

（Cplusplus基础与提高（何桂林）200页）

类模板：

1.类模板的定义：
可用类模板来定义类，类模板是对象特性更为一般的抽象。简而言之，一个类模板就是一个抽象的类、类模板的一般定义形式为：

template<参数名列表>
class 类名{
    //类的说明
};

其中，template是关键字，<参数名列表>中可以有多个参数，多个模板参数之间用逗号分隔。模板参数的形式可以是：

class<标识符> 或 类型表达式<标识符>

如，可定义坐标点的类模板如下：

template <class T>          //带参数T的类模板说明
class Point{
public:
    Point(T = 0,T = 0);     //类的构造函数
    Point(Point&);          //类的复制构造函数
    T Distance(Point&);     //返回类型为T的成员函数
private:
    T x,y;
};

2**.类模板的使用**：
使用上述模板定义对象iobj，并以int替换参数T：

Point<int> iobj(3,4);  //该对象产生一个int型的点(3,4)

使用该模板再产生一个实例：

Point<double>dobj(7.8,8.8);     //该对象产生一个double型的坐标点（7.8，8.8）

由此可见，使用类模板可以声明不同类型的对象。对于一个可能用到多种数据类型的类来说，使用类模板可以大大提高编程的效率。简单地说，如果你需要int型的数据，就用int来替换参数模板中的T，需要double型的数据就用double来替换参数模板中的T。

以下代码给出了一个用类模板来描述坐标点的例子：

#include<iostream>
#include<cmath>
 
//The declaration of class template
template<class T>
class Point{
public:
    Point(T = 0,T = 0);
    Point(Point&);
    T Distance(Point&);
private:
    T x,y;
};
 
//The implementation of class template Point
template<class T>
Point<T>::Point(T a,T b):x(a),y(b){}
 
template<class T>
Point<T>::Point(Point& a)
{
    x = a.x;
    y = a.y;
}
 
template<class T>
T Point<T>::Distance(Point& a)
{
    return sqrt((x - a.x)*(x - a.x) + (y - a.y)*(y - a.y));
}
 
//main function
int main()
{
    using namespace std;        //Learn the meaning of "namespace" from 《C++ primer》
    Point<int>a1(3,4),a2(5,6);
    cout<<"The distance of these two points(int): "<<a1.Distance(a2)<<endl;
 
    Point<double>b1(7.8,9.8),b2(34.8,25.4);
    cout<<"The distance of these two points(double): "<<b1.Distance(b2)<<endl;
    return 0;
}

下图为运行结果：

显然，使用类模板能使得我们在处理需要多种数据类型的类时游刃有余，从上述程序中我们也很容易发现类模板与普通的类之间的差别。其实，只要去掉类模板的声明，并将T换成我们所需要的数据类型，再做些微小的改动就成为了一个普通的类。认识到这一点，对类模板的理解就会更加深刻。

智能指针

在Android的源代码中，经常会看到形如：sp<xxx>、wp<xxx>这样的类型定义，这其实是Android中的智能指针。智能指针是C++中的一个概念，通过基于引用计数的方法，解决对象的自动释放的问题。在C++编程中，有两个很让人头痛的问题：一是忘记释放动态申请的对象从而造成内存泄露；二是对象在一个地方释放后，又在别的地方被使用，从而引起内存访问错误。程序员往往需要花费很大精力进行精心设计，以避免这些问题的出现。在使用智能指针后，动态申请的内存将会被自动释放（有点类似Java的垃圾回收），不需要再使用delete来释放对象，也不需要考虑一个对象是否已经在其它地方被释放了，从而使程序编写工作减轻不少，而程序的稳定性大大提高。
Android的智能指针相关的源代码在下面两个文件中：
frameworks/base/include/utils/RefBase.h
frameworks/base/libs/utils/RefBase.cpp

Android中定义了两种智能指针类型，一种是强指针sp（strong pointer），一种是弱指针（weak pointer）。其实成为强引用和弱引用更合适一些。强指针与一般意义的智能指针概念相同，通过引用计数来记录有多少使用者在使用一个对象，如果所有使用者都放弃了对该对象的引用，则该对象将被自动销毁。
弱指针也指向一个对象，但是弱指针仅仅记录该对象的地址，不能通过弱指针来访问该对象，也就是说不能通过弱智真来调用对象的成员函数或访问对象的成员变量。要想访问弱指针所指向的对象，需首先将弱指针升级为强指针（通过wp类所提供的promote()方法）。弱指针所指向的对象是有可能在其它地方被销毁的，如果对象已经被销毁，wp的promote()方法将返回空指针，这样就能避免出现地址访问错的情况。
是不是很神奇？弱指针是怎么做到这一点的呢？其实说穿了一点也不复杂，原因就在于每一个可以被智能指针引用的对象都同时被附加了另外一个weakref_impl类型的对象，这个对象中负责记录对象的强指针引用计数和弱指针引用计数。这个对象是智能指针的实现内部使用的，智能指针的使用者看不到这个对象。弱指针操作的就是这个对象，只有当强引用计数和弱引用计数都为0时，这个对象才会被销毁。
说了这么多原理，下面该看看到底智能指针该怎么使用了。假设现在有一个类MyClass，如果要使用智能指针来引用这个类的对象，那么这个类需满足下列两个前提条件：
（1）这个类是基类RefBase的子类或间接子类；
（2）这个类必须定义虚构造函数，即它的构造函数需要这样定义：
virtual ~MyClass();
满足了上述条件的类就可以定义智能指针了，定义方法和普通指针类似。比如普通指针是这样定义：
MyClass* p_obj;
智能指针是这样定义：
sp<MyClass> p_obj;
注意不要定义成 sp<MyClass>* p_obj。初学者容易犯这种错误，这样实际上相当于定义了一个指针的指针。尽管在语法上没有问题，但是最好永远不要使用这样的定义。
定义了一个智能指针的变量，就可以象普通指针那样使用它，包括赋值、访问对象成员、作为函数的返回值、作为函数的参数等。比如：

sp<MyClass> p_obj;
p_obj = new MyClass(); // 注意不要写成 p_obj = new sp<MyClass>
sp<MyClass> p_obj2 = p_obj;
p_obj->func();
p_obj = create_obj();
some_func(p_obj);

注意不要试图delete一个智能指针，即 delete p_obj。不要担心对象的销毁问题，智能指针的最大作用就是自动销毁不再使用的对象。不需要再使用一个对象后，直接将指针赋值为NULL即可：
p_obj = NULL;
上面说的都是强指针，弱指针的定义方法和强指针类似，但是不能通过弱指针来访问对象的成员。下面是弱指针的示例：

wp<MyClass> wp_obj = new MyClass();
p_obj = wp_obj.promote(); // 升级为强指针。不过这里要用.而不是->，真是有负其指针之名啊
wp_obj = NULL;

智能指针用起来是很方便，在一般情况下最好使用智能指针来代替普通指针。但是需要知道一个智能指针其实是一个对象，而不是一个真正的指针，因此其运行效率是远远比不上普通指针的。所以在对运行效率敏感的地方，最好还是不要使用智能指针为好。