C++博客-天下-随笔分类-C++必杀技法

[原创]一个C++异常的代替方案

天下 — Fri, 21 Aug 2015 07:34:00 GMT

#include "stdafx.h"

template
class E
{
public:
    T val;
    int errcode;

    E(){}

    E(const T& val)
    {
        val = val;
    }

    operator T() const
    {
        return val;
    }
    operator T*()
    {
        return &val;
    }
    E operator=(const T& _val)
    {
        val = _val;
        return *this;
    }
public:
    int fail() const
    {
        return errcode;
    }

};

E<int> GetResult(bool fail)
{
    E<int> obj;
    obj.val = 0x1000;
    obj.errcode = fail;
    return obj;
}

int _tmain(int argc, _TCHAR* argv[])
{
    E<int> a;
    a.val = 5;
    a.errcode = false;

    int b = a;
    int* c = a;
    *c = 7;
    const int* d = a;

    unsigned int e = a = 8;

    E<int> x = GetResult(true);

    if (x.fail())
        printf("error \r\n");
    else
        printf("succeed \r\n");

    if (a.fail())
        printf("error \r\n");

    return 0;
}

天下 2015-08-21 15:34 发表评论

C语言实现有限状态机

天下 — Mon, 04 Mar 2013 10:00:00 GMT

C语言实现有限状态机

有限状态机(finite state machine)是一个数学概念，如果把它运用于程序中，可以发挥很大的作用。它是一种协议，用于有限数量的子程序(”状态”)的发展变化。每个子程序进行一些处理并选择下一种状态(通常取决于下一段输入)。

有限状态机(FSM)可以用作程序的控制结构。FSM对于那些基于输入的在几个不同的可选动作中进行循环的程序尤其合适。投币售货机就是FSM的一个好例子。另外一个你可以想到的复杂的例子就是你正在用的东西，想到了吗？没错，就是操作系统。在投币售货机的例子中，输入是硬币，输出是待售商品，售货机有” 接受硬币”，”选择商品”，”发送商品”和”找零钱”等几种状态。

它的基本思路是用一张表保存所有可能的状态，并列出进入每个状态时可能执行的所有动作，其中最后一个动作就是计算(通常在当前状态和下一次输入字符的基础上，另外再经过一次表查询)下一个应该进入的状态。你从一个”初始状态” 开始。在这一过程中，翻译表可能告诉你进入了一个错误状态，直到到达结束状态。

在C语言中，有好几种方法可以用来表达FSM，但它们绝大多数都是基于函数指针数组。一个函数指针数组可以像下面这样声明：

void (*state[MAX_STATES]) ();

如果知道了函数名，就可以像下面这样对数组进行初始化。

extern int a(),b(),c(),d();
int (*state[]) ()={a,b,c,c};

可以通过数组中的指针来调用函数：
(*state[i]) ();

所有函数必须接受同样的参数，并返回同种类型的返回值(除非你把数组元素做成一个联合)。函数指针是很有趣的。注意，我们可以去掉指针形式，把上面的调用写成：

state[i] ();

甚至
(***state[i]) ();

这是一个在ANSI C中流行的不良方法：调用函数和通过指针调用函数(或任意层次的指针间接引用)可以使用同一种语法。

如果你想干得漂亮一点，可以让状态函数返回一个指向通用后续函数的指针，并把它转换为适当的类型。这样，就不需要全局变量了。如果你不想搞得太花哨，可以使用一个switch语句作为一种简朴的状态机，方法是赋值给控制变量并把switch语句放在循环内部。关于FSM还有最后一点需要说明：如果你的状态函数看上去需要多个不同的参数，可以考虑使用一个参数计数器和一个字符串指针数组，就像main函数的参数一样。我们熟悉的int argc,char *argv[]机制是非常普遍的，可以成功地应用在你所定义的函数中

天下 2013-03-04 18:00 发表评论

C++ pimpl 技法

天下 — Sat, 05 Nov 2011 09:40:00 GMT

pimpl idiom..指向实现的指针

//pimpl 这种做法还保障了二进制兼容性，让动态库的升级变得更容易。
//隐藏了实现的细节.
//C++代码
// A.h

class AImpl;

class A {
public:
    A();
    ~A();
    void func();

private:
    A(const A&);
    void operator=(const A&);
    AImpl* impl_;
}；

// A.cpp

class AImpl {
public:
    void func();
private:
    int myFunc(int myParam);
private:
    int _myVariable;
};

A::A()
: impl_(new AImpl)
{
}

A::~A()
{
    delete impl_;
}

void A::func()
{
    impl_->func();
}

// A.h
//pimplidiom 指向实现的指针
//pimpl 这种做法还保障了二进制兼容性，让动态库的升级变得更容易。
//隐藏了实现的细节.
#pragma once

class A {
public:
    A();
    ~A();
    void func();

private:
    A(const A&);
    void operator=(const A&);
    class AImpl;  // 声明，不是定义
    AImpl* impl_;
};

// A.cpp
// 在这里定义，完全不暴露
#include "a.h"
class A::AImpl {
public:
    void func(){

    }
private:
    int myFunc(int myParam);
private:
    int _myVariable;
};

A::A()
: impl_(new AImpl)
{
}

A::~A()
{
    delete impl_;
}

void A::func()
{
    impl_->func();
}

天下 2011-11-05 17:40 发表评论

C++ RAII

天下 — Tue, 22 Mar 2011 06:25:00 GMT

C++ RAII

    RAII是resource acquisition is initialization的缩写，意为“资源获取即初始化”。它是C++之父Bjarne Stroustrup提出的设计理念，其核心是把资源和对象的生命周期绑定，对象创建获取资源，对象销毁释放资源。在RAII的指导下，C++把底层的资源管理问题提升到了对象生命周期管理的更高层次。
    说起来，RAII的含义倒也不算复杂。用白话说就是：在类的构造函数中分配资源，在析构函数中释放资源。这样，当一个对象创建的时候，构造函数会自动地被调用；而当这个对象被释放的时候，析构函数也会被自动调用。于是乎，一个对象的生命期结束后将会不再占用资源，资源的使用是安全可靠的。
C++ RAII体现出了简洁、安全、实时的特点：

1.概念简洁性：让资源（包括内存和非内存资源）和对象的生命周期绑定，资源类的设计者只需用在类定义内部处理资源问题，提高了程序的可维护性
2.类型安全性：通过资源代理对象包装资源（指针变量），并利用运算符重载提供指针运算方便使用，但对外暴露类型安全的接口
3.异常安全性：栈语义保证对象析构函数的调用，提高了程序的健壮性
4.释放实时性：和GC相比，RAII达到了和手动释放资源一样的实时性，因此可以承担底层开发的重任

也许你还在惊讶RAII如此简单的时候，关于RAII的主要内容已经介绍完了。简单不意味着简陋，在我看来RAII虽然不像GC一样，是一套具体的机制，但它蕴含的对象与资源关系的哲学深度的理解却使得我对Bjarne Stroustrup肃然起敬！

最后，不得不提醒RAII的理念固然简单，不过在具体实现的时候仍有需要小心的地方。比如对于STL的auto_ptr，可以视为资源的代理对象，auto_ptr对象间的赋值是一个需要特别注意的地方。简单说来资源代理对象间赋值的语义不满足“赋值相等”，其语义是资源管理权的转移。

什么是“赋值相等”呢？比如：

int a;  int b = 10;  a = b; //这句话执行后 a == b 但对于资源代理对象，这是不满足的，比如：

auto_ptr<int> a(null);  auto_ptr<int> b(new int(123));  a = b; //这句话执行后a != b，赋值的语义是b把资源的管理权交给了a

auto_ptr是这样一种指针：它是“它所指向的对象”的拥有者。这种拥有具有唯一性，即一个对象只能有一个拥有者，严禁一物二主。当auto_ptr指针被摧毁时，它所指向的对象也将被隐式销毁，即使程序中有异常发生，auto_ptr所指向的对象也将被销毁。

关于auto_ptr的几种注意事项：
1、auto_ptr不能共享所有权。
2、auto_ptr不能指向数组
3、auto_ptr不能作为容器的成员。
4、不能通过赋值操作来初始化auto_ptr
std::auto_ptr<int> p(new int(42));     //OK
std::auto_ptr<int> p = new int(42);    //ERROR
这是因为auto_ptr 的构造函数被定义为了explicit
5、不要把auto_ptr放入容器

下面便是在C++中实现RAII的典型代码：
class file
{
public:
    file(string const& name) {
        m_fileHandle=fopen(name.cstr());
    }
    ~file() {
        fclose(m_fileHandle);
    }
    //
private:
    handle m_fileHandle;
}

很典型的“在构造函数里获取，在析构函数里释放”。如果我写下代码：
void fun1() {
    file myfile("my.txt");
     //操作文件
} //此处销毁对象，调用析构函数，释放资源
当函数结束时，局部对象myfile的生命周期也结束了，析构函数便会被调用，资源会得到释放。而且，如果函数中的代码抛出异常，那么析构函数也会被调用，资源同样会得到释放。所以，在RAII下，不仅仅资源安全，也是异常安全的。

但是，在如下的代码中，资源不是安全的，尽管我们实现了RAII：
void fun2() {
    file pfile=new file("my.txt");
     //操作文件
}
因为我们在堆上创建了一个对象（通过new），但是却没有释放它。我们必须运用delete操作符显式地加以释放：
void fun3() {
    file pfile=new file("my.txt");
     //操作文件
        delete pfile;
}
否则，非但对象中的资源得不到释放，连对象本身的内存也得不到回收。（将来，C++的标准中将会引入GC（垃圾收集），但正如下面分析的那样，GC依然无法确保资源的安全）。
现在，在fun3()，资源是安全的，但却不是异常安全的。因为一旦函数中抛出异常，那么delete pfile;这句代码将没有机会被执行。

C++领域的诸位大牛们告诫我们：如果想要在没有GC的情况下确保资源安全和异常安全，那么请使用智能指针：
void fun4() {
    auto_ptr<file> spfile(new file("my.txt"));
     //操作文件
} //此处，spfile结束生命周期的时候，会释放（delete）对象
那么，智能指针又是怎么做到的呢？下面的代码告诉你其中的把戏（关于智能指针的更进一步的内容，请参考std::auto_ptr，boost或shared_ptr的智能指针）。
也就是说，智能指针通过RAII来确保内存资源的安全，也间接地使得对象上的RAII得到实施。不过，这里的RAII并不是十分严格：对象（所占的内存也是资源）的创建（资源获取）是在构造函数之外进行的。广义上，我们也把它划归RAII范畴。
但是，Matthew Wilson在《Imperfect C++》一书中，将其独立出来，称其为RRID（Resource Release Is Destruction）。
RRID的实施需要在类的开发者和使用者之间建立契约，采用相同的方法获取和释放资源。比如，如果在shared_ptr构造时使用malloc()，便会出现问题，因为shared_ptr是通过delete释放对象的。

天下 2011-03-22 14:25 发表评论

C++语言的动态联编技术剖析

天下 — Wed, 27 Oct 2010 01:12:00 GMT

联编的概念
在C++中,联编(binding)就是使一个计算机程序的不同部分彼此关联的过程.
在这个过程中对将每个函数调用分配内存地址,并且对外部访问也分配正确的内存地址,根据进行联编所处阶段的不同,可以分为两种不同的联编方法:静态联编和动态联编(滞后联编).

在编译阶段决定执行哪个同名的被调用函数,称为静态联编.
静态联编在编译阶段就必须了解所有的函数或模块执行所需要检测的信息,它对函数的选择是基于指向对象的指针(或者引用)的类型.

反之在编码阶段不能决定执行哪个同名的被调用函数,只在执行阶段才能根据地要处理的对象类型来决定执行哪个类的成员函数,这称为动态联编.
动态联编对成员函数的选择不是基于指针或引用,而是基于对象类型,针对不同的对象类型将作出不同的编译结果.
当涉及到多态性和虚函数时就应该使用动态联.

动态联编必须包括以下方面：
成员函数必须申明为virtual
如果基类中申明了为虚函数，则派生类中不必再申明。

调用方式：
通过对象的指针或引用调用成员函数；或通过成员函数调用

C++多态性机制
多态性在C++里面具体表现为:通过基类指针访问派生类的函数和方法.

代码如下:

#include   <iostream>
#include   <typeinfo>
using namespace std;
class   A
{
public:
    virtual   void   fun(void)
    {
        cout << "This   is   class   A! " <<endl;
    }
};
class   B   :   public   A
{
public:
    void   fun(void)
    {
        cout << "This   is   class   B! " <<endl;
    }
};
int main(void)
{
    A   aa,*p;
    B   bb;
    p=&bb;
    p-> fun();
    p=&aa;
    p-> fun();
    return 0;
}

天下 2010-10-27 09:12 发表评论