C++博客-yg2362-随笔分类-C++

Unicode和UTF-8的区别

梨树阳光 — Sun, 23 Sep 2012 14:56:00 GMT

如果你对能很快回答出unicode和utf-8的关系，你可以直接跳过这篇文章。下面我来说说两者的关系和转换。（本文使用符号2字代表所有的汉字，英文，数字等）
首先明确一点，UTF-8是UNICODE一种实现方式。
UNICODE：代表一种符号集合，它规定了一种符合的二进制表示，没有指明存储方式。(http://www.unicode.org/)
UTF-8:实现了UNICODE，使用多字节的存储方式。
我们先来考虑几个问题。
第一，如果使用单字节表示符号，很明显，完全不够用
第二，如果使用多字节表示符号，那么，机器在读取的时候，它怎么知道3个字节表示一个符号，还是表示3个符号
第三，如果使用2个字节表示一个符号，首先，最多能表示65535个字符还是会不够用，就算够用，比如ASCII码这类仅需1个字节就可以表示的符号，用2个字节表示，浪费空间了。
因此，UTF-8孕育而生。
首先UTF-8使用变长表示符号，简单的说，有的时候用1个字节表示符号，有的时候用2个字节表示符号，这样解决了浪费空间的问题。那么，如何解决第二个问题的呢，我们得了解下UFT-8的编码规则。
1.对于单字节的符号，字节第一个为0，后面7为为这个符号的unicode码
2.对于N字节的符号(N>1),第一个字节前N位为1，第N+1位为0，后面字节的前两位设为10,剩下可编码的位，为该符号的UNICODE编码。
这里我从网上找了一副图
Unicode符号范围 | UTF-8编码方式
(十六进制) | （二进制）
0000 0000-0000 007F | 0xxxxxxx
0000 0080-0000 07FF | 110xxxxx 10xxxxxx
0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx
0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
下面我具体解释下这幅图。
首先看第一行，它的意思是00000000到0000007F的UNICODE编码，对应的UTF-8的编码方式为0XXXXXXX(X表示可编码位，不足的补0)。
第二行表示00000080到000007FF的UNICODE编码，对应的UTF-8的编码方式为110XXXXX 10XXXXXX。以此类推
那么，问题是，这个范围是怎么定的？
很简单，我们还是从第一行说起。007F，实际有效位只有7位，所以，0xxxxxxx就足矣。但是0800开始，有效位至少为8位，我们得增加一个字节，按照UTF-8的规定，2字节的表示方式为110XXXXX 10XXXXXX，我们的编码位为11位(X的个数)，所以，我们最多可以表示UNICODE编码位11位的字符，也就是07FF。07FF过了就是0800，有效位至少为12位，我们得用3字节来表示，按照UTF-8的规定，1110XXXX 10XXXXXX 10XXXXXX，最大编码位为16位，也就是FFFF，最后一行我就不再解释了。
通过上面这个过程我们了解了，UNICODE转UTF-8的过程，当然，逆过来就是UTF-8转换成UNICODE。
我们通过一个例子来演示上面的过程。汉字“杨”，UNICODE的编码位0x6768，二进制形式为0110011101101000，根据上面的图，我们知道它属于第三行，因此，它应该放入1110XXXX 10XXXXXX 10XXXXXX的模板中，结果是11100110 10011101 10101000，十六进制表示为E69DA8。
另外设计编码问题，我们绕不开另一个问题，就是大端小端的问题，不过这个问题，网上资料很多，也很好实践，这里我就不多啰嗦了。

梨树阳光 2012-09-23 22:56 发表评论

C++复习笔记---浅谈拷贝构造函数和赋值构造函数

梨树阳光 — Fri, 31 Aug 2012 09:13:00 GMT

1.拷贝构造函数的形式

对于类X，如果它的函数形式如下

a) X&

b) const X&

c) volatile X&

d) const volatile X&

且没有其他参数或其他参数都有默认值,那么这个函数是拷贝构造函数

X::X(const X&);是拷贝构造函数

X::X(const X&,int val = 10);是拷贝构造函数

2.一个类中可以存在超过一个拷贝构造函数

class X {

public:

X(const X&);

X(X&); // OK

};

编译器根据实际情况调用const拷贝构造函数或非const的拷贝构造函数

3.默认的拷贝构造函数行为

a)先调用父类的拷贝构造函数

b)如果数据成员为一个类的实例，则调用该类的拷贝构造函数

c)其他成员按位拷贝

4.默认的赋值构造函数行为

a)先调用父类的赋值构造函数

b)如果数据成员为一个类的实例，则调用该类的赋值构造函数

c)其他成员按位拷贝

5.提供显示的拷贝和赋值构造函数

基本的原则是子类一定要调用父类的相应函数，参考方式

Derive(const Derive& obj):Base(obj)

{

…...

}

Derive& operator =(const Derive &obj)

{

if ( this == &obj )

return *this;

//方式一

Base::operator =(obj);

//方式二

static_cast&>(*this) = obj;

return *this;

}

另外当你的成员变量有const或者引用，系统无法为你提供默认的拷贝和赋值构造函数，我们必须自己处理这些特殊的情况

梨树阳光 2012-08-31 17:13 发表评论

C++复习笔记---类的函数指针和普通函数指针

梨树阳光 — Tue, 14 Aug 2012 09:17:00 GMT

我们在类里面会定义成员函数，同时我们也希望定义成员函数指针。因此需要解决3个问题，第一怎么定义类的函数指针，第二赋值，第三使用。
我定义一个类，

class A
{
public:
    int add(int,int);
    int mul(int,int);
    int div(int,int);
};

int A::add(int a,int b)
{
    return a + b;
}

int A::mul(int a,int b)
{
    return a * b;
}

int A::div(int a,int b)
{
    return (b !=0 ? a/b : a);
}

我现在想要定义一个指针，指向A类型中返回值为int，参数为两个int的函数指针。熟悉C的同学马上会写出typedef int (*oper)(int,int)。但是这个用到C++里就有问题了，
因为我们知道，类的非static成员方法实际上还有this指针的参数。比如add方法，它实际的定义可能会这样int add(A* this,int a,int b);因此，我们不能简单把C语言里的那套东西搬过来，我们需要重新定义这种类型的指针。正确做法是加上类型，typedef int (A::*Action)(int,int)

typedef int (A::* Action)(int,int);

int main()
{
    A a;
    Action p = &A::add;
    cout << (a.*p)(1,2) << endl;
    return 0;
}

Action p = &A::add;这个就是赋值语句
调用的时候注意，直接这样(*p)(1,2)是不行的，它必须绑定到一个对象上(a.*p)(1,2);我们也可以把类的函数指针定义在类的声明里。

class A
{
public:
    int add(int,int);
    int mul(int,int);
    int div(int,int);

    int (A::*oper)(int,int);
};

上面这种方式是针对非static成员函数的，那么static成员函数的函数指针应该怎么定义呢，还能用上面这种方式吗？我们知道static成员函数是没有this指针的，所以不会加上的类的限定，它的函数指针定义方式和C里面的函数指针定义方式一样的。

class A
{
public:
    int add(int,int);
    int mul(int,int);
    int div(int,int);

    static int sub(int,int);
};

int A::sub(int a,int b)
{
    return a - b;
}

int main()
{
    int (*pp)(int,int) = &A::sub;
    cout << (*pp)(10,5) << endl;

    return 0;
}

总结起来，非static成员函数的函数指针需要加上类名，而static的成员函数的函数指针和普通的函数指针一样，没有什么区别。
另外注意一点的是
如果函数指针定义在类中，调用的时候有点区别。

class A
{
public:

    int add(int,int);
    int mul(int,int);
    int div(int,int);

    int (A::*pfunc)(int,int);
};

int main()
{
    A a;
    a.pfunc = &A::add;
    cout << (a.*(a.pfunc))(1,2) << endl;
    return 0;
}

梨树阳光 2012-08-14 17:17 发表评论

C++复习笔记---初始化列表

梨树阳光 — Tue, 14 Aug 2012 02:24:00 GMT

很久没有碰C++，下个项目要开始使用C++，所以很多东西需要捡起来重新看看。从今天起记录一些笔记，方便自己今后查阅。言归正传，先从构造函数的初始化列表说起。我把这个知识点细化成3个问题，1.为什么要有初始化列表，它和构造函数中初始化有什么不一样。2.初始化的顺序。3.一些注意的细节。
先说第一个问题。我们有两个东西，是必须在初始化列表里完成的，一个是const修饰的变量，一个是引用。这点我就不细说了，查阅资料的都可以找到。下面我具体说说类成员。

class Test1

{

public:

Test1()

{

cout << "Test1 default constructor" << endl;

}

Test1(int i)

{

cout << "Test1 value constructor" << endl;

}

Test1(const Test1 &obj)

{

cout << "Test1 copy constructor" << endl;

}

Test1& operator = (const Test1 &obj)

{

cout << "Test1 = constructor" << endl;

return *this;

}

~Test1()

{

cout << "Test1 destructor" << endl;

}

};

我定义一个类，然后再定义一个类，其中包含Test1

class Test2
{
public:
    Test2()
    {
        t1 = Test1(1);
    }

private:
    Test1 t1;
};

我们在构造函数中初始化Test1，我们看看运行结果

Test1 default constructor

Test1 value constructor

Test1 = constructor

Test1 destructor

Test1 destructor
我们分析下这个输出。Test1 default constructor，这说明在进入Test1构造函数之前，已经初始化了t1成员，并且调用的是无参构造函数。Test1 value constructor这个是Test1(1)创建出来的对象。Test1 = constructor，这个表示条用了拷贝构造函数，Test1 destructor这个表示Test1(1)这个临时对象的析构，Test1 destructor这个表示是t1这个成员对象的析构。从上面的结果来看，构造函数中t1 = Test1(1);其实并不是真正意义是上的初始化，而是一次拷贝赋值。当进入构造函数内部之前，类成员会被默认构造函数初始化。如果说Test1是个很大的对象，这块会造成性能上的开销。所以，这点也是使用初始化列表的原因之一。
第二我们再来说下顺序问题。简单的原则是初始化列表里的会先于构造函数中，初始化列表里会按照变量声明的顺序。我们具体看看下面的例子。
class Test3()

{
public:
    Test3(int x,int y,int z):_z(z),_y(y)
    {
        _x = x;
    }

private:
    int _x,_y,_z;
};

按照上面的说法，赋值的顺序是_y,_z,_x。
第三个是注意问题，每个成员只能在初始化列表里出现一次。
class Test3

{
public:
    Test3(int x,int y,int z):_z(z),_y(y),_z(x)
    {
        _x = x;
    }

private:
    int _x,_y,_z;
};

比如这种就是问题的。_z被初始化了2次。

梨树阳光 2012-08-14 10:24 发表评论