fft淺析

Sat, 03 Nov 2012 16:10:00 GMT

一直都被fft吸引著，翻了下《信號與系統》，用純c++實現了一遍，算是把原理弄透了，然後想到了多項式擬合，翻書翻到了內積空間，還淺淺地了解一下小波分析，覺得用隨筆來把原理說透恐怕篇幅不夠，還是先弄個文檔什麽的吧
這裡先放幾張圖開個頭，有時間補全再說吧，顯示部份用了mgl

主要就是驗證一下把方波拆分成不同頻率的信號

廷 2012-11-04 00:10 发表评论

c++成员变量反射

Wed, 25 Apr 2012 05:18:00 GMT

　　最近（其实也有一段时间了），在c++项目中需要用到类似java的反射机制，时间也比较赶，只能周围看看有没有现成的库可用了，找到的资料也不算少，但多数都是关于动态创建类的，有点像工厂模式，而我需要的，是把实体类中的属性反射出来。最后，找到了一个叫LibReflection的东西，虽然后来还是没用上这个，但是稍微看了一下代码，还是有不少收获，所以就在这里记录下来了，当做学习，也当做对这个库的一个分析吧。
　　LibReflection是属性和函数反射都有实现的，而整个库竟然就一个h文件，本人精力有限，只把属性反射抽取出来，相信离实际应用也有距离，如果有人路过看到，请体谅别拍砖了。
　　那么，首先看一下使用：

TestClass inst;
    tat::tat_class *test_class = TestClass::get_class_ptr();
    std::mapstring,tat::tat_field> field_map = test_class->get_fields();
    tat::tat_field test_vec_field = field_map.find("_vec_f")->second;
    std::vector<int> vec;
    test_vec_field.get(&inst,vec);
    vec.push_back(22);
    test_vec_field.set(&inst,vec);
    std::cout<
　　TestClass类先不给出，反正就是该类有一个名字为“_vec_f”的属性，类型是std::vector，然后这段代码通过反射修改_vec_f的内容。。至于tat_class和tat_field，相信熟悉java的人都能猜出是什么了。
　　获取及设置一个实例的成员变量的值不是难事，用一个宏就可以了：

#define _OFFSET_(_Obj_Ty,_Key) \
((unsigned long)(&((_Obj_Ty *)0)->_Key))

　　这个宏应该也不难理解，就是获取成员变量相对实例指针的偏移值。而关键问题是，如何通过变量名称就能查找出这个偏移呢？如何在变量初始化的时候就能记录下这个偏移呢？我们可以通过宏来声明变量，那么声明的时候就可以做一些事情了，但具体做些什么，还是没头绪。
　　这个问题自己思考了一段时间，无果。然后看了一下实现，深感自己的基础还没过关，其实说白了就是两个东西：构造函数、静态成员变量。
　　我们的目标是很明确的，要做到java的效果，结合上面那个宏，也不难想象出Class和Field类的样子（这里是tat_class和tat_field），tat_class无非就是保存了一个map，key是属性的名称，value是tat_field，至于tat_field就简单了，核心就是保存内存的偏移值，再提供操作值的接口就可以了。
　　先来看看tat_class：

  class tat_class
    {
    private:
        std::mapstring,tat_field> _field_map;
        std::string _key;
    public:
        std::mapstring,tat_field> get_fields()
        {
            return this->_field_map;
        }
        tat_field get_field(std::string key)
        {
            std::mapstring,tat_field>::iterator itr = _field_map.find(key);
            return (*itr).second;
        }
        void add_field(const tat_field &field)
        {
            _field_map.insert(std::pairstring,tat_field>(field.get_key(),field));
        }
    };

　　没有什么理解上的难点吧。
　　然后看看tat_field：

  class tat_field
    {
    private:
        unsigned long _offset;
        std::string _key;
    public:
        tat_field(unsigned long offset,std::string key):_offset(offset),_key(key){}
        tat_field(const tat_field &field)
        {
            this->_offset = field._offset;
            this->_key = field._key;
        }
    public:
        template
        void get(_Obj_Ty *obj,_Value_Ty &value)
        {
            value = *((_Value_Ty *)((unsigned char *)obj + _offset));
        }
        template
        void set(_Obj_Ty *obj,const _Value_Ty &value)
        {
            *((_Value_Ty *)((unsigned char *)obj + _offset)) = value;
        }
        std::string get_key() const
        {
            return this->_key;
        }
    };

　　变量值的get和set函数使用了模板，这是为了使用的时候能作简单的类型推断。
　　然后就是重点了，如何在声明类的时候就把tat_class注入呢？如前面说的，静态成员变量：

#define CLASS_REGISTER(_Obj_Ty)                                                    \
public:                                                                            \
    static tat::tat_class * get_class_ptr()                                        \
    {                                                                            \
        static tat::tat_class __class_##_Obj_Key##__;                            \
        return &__class_##_Obj_Key##__;                                            \
    }

　　这个宏做了两件事：第一，声明静态函数get_class_ptr()，返回tat_class类型，第二，当然就是初始化tat_class了，因为同样是静态，所以不同的实例就共享了。
　　接下来是另一个重点，如何在声明成员变量的时候把tat_field注入到tat_class中，还是用宏解决：

#define FIELD_REGISTER(_Access,_Field_Ty,_Field_Key,_Obj_Ty)                    \
_Access:                                                                        \
    _Field_Ty _Field_Key;                                                        \
private:                                                                        \
    class __field_register_##_Field_Key##__                                        \
    {                                                                            \
    public:                                                                        \
        __field_register_##_Field_Key##__()                                        \
        {                                                                        \
            static tat::__field_register__ reg_##_Field_Key(                    \
                _Obj_Ty::get_class_ptr(),                                        \
                _OFFSET_(_Obj_Ty,_Field_Key),                                    \
                #_Field_Key);                                                    \
        }                                                                        \
    }_Field_Key##_register;

　　分析这个宏，首先当然是声明变量了；然后就是一个神秘的类：__field_register_##_Field_Key##__，这个类就只有一个构造函数，构造函数里面又是一个静态变量，类型是tat::__field_register__，可以想象得到，既然tat_class已经可以声明出来了，tat_field自然也没有难度，但声明是不足够的，还需要放到tat_class的map里面才算完成，在声明一个变量的时候，能做事的地方，我只能想到是构造函数了，所以就有了刚刚那个神秘的类，那个类的唯一作用就是其构造函数，而构造函数里面声明静态变量，则是防止多次实例化类带来的冗余数据，确保一个成员变量只有一个tat_field；
　　剩下的关键，就是tat::__field_register__了：

  class __field_register__
    {
    public:
        __field_register__(tat_class *class_ptr,unsigned long offset,std::string key)
        {
            tat_field field(offset,key);
            class_ptr->add_field(field);
        }
    };

　　没有什么神秘的地方，这个东西就这么完成了。
　　差点忘了TestClass的声明：

#include "fieldref.h"

class TestClass
{
public:
    TestClass(void);
    ~TestClass(void);

    CLASS_REGISTER(TestClass)
    FIELD_REGISTER(public,long,_long_f,TestClass)
    FIELD_REGISTER(public,int,_int_f,TestClass)
    FIELD_REGISTER(public,std::string,_str_f,TestClass)
    FIELD_REGISTER(public,std::vector<int>,_vec_f,TestClass)
};

　　好吧，如果说到实际应用的问题，洒家确实没有考虑太多，反正测试函数能跑，结果也对了，洒家也就满足了，就单纯的当做是一次实验，或者是学习而已。

廷 2012-04-25 13:18 发表评论

C++博客-cpp小菜園

fft淺析

c++成员变量反射