久久99精品国产99久久,日韩久久无码免费毛片软件,欧美激情一区二区久久久

c++ traits(1)

天下 — Fri, 14 Oct 2016 06:18:00 GMT

#pragma once
template <typename T>
struct TraitsHelper;

template <typename T>
struct TraitsHelper {
    static const bool isPointer = false;
    enum {IsPointer = false};
    bool GetIsPointer()
    {
        return IsPointer;
    }
};
template <typename T>
struct TraitsHelper<T*> {
    static const bool isPointer = true;
    enum {IsPointer = true};
    bool GetIsPointer()
    {
        return IsPointer;
    }
};

//call
#include "stdafx.h"
int _tmain(int argc, _TCHAR* argv[])
{
    int val = 0;
    int* pVal = &val;
    TraitsHelper<int> a;
    TraitsHelper<int*> b;

    bool b1 = a.IsPointer;
    bool b2 = b.IsPointer;

    bool b3 = a.GetIsPointer();

    bool b4 = TraitsHelper<int>::IsPointer;
    bool b5 = TraitsHelper<int*>::IsPointer;

    return 0;
}

天下 2016-10-14 14:18 发表评论

天下 — 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 发表评论

MapStream

天下 — Mon, 07 Apr 2014 05:52:00 GMT

#pragma once
#include <map>
#include <cstdio>

#ifdef _WIN32
    #include <sys/stat.h>
#else
#endif

template<typename Key,typename Value>
class MapStream
{
public:
    std::map<Key,Value> m_mapTable;
    typedef typename std::map<Key,Value>::iterator MapStreamIterator;

    int GetFileSize(const char* filename)
    {
        struct stat f_stat;
        if (stat(filename, &f_stat) == -1) {
            return -1;
        }
        return f_stat.st_size;
    }

    bool Load(const char* filename)
    {
        FILE* fp = fopen(filename,"rb");
        if (fp ==NULL)
            return false;

        int metasize = sizeof(Key) + sizeof(Value);
        char buffer[sizeof(Key) + sizeof(Value)];
        int  readed;
        Key* _key;
        Value* _value;

        m_mapTable.clear();
        while (fread(buffer,1,metasize,fp)==metasize)
        {
            _key    = (Key*)buffer;
            _value    = (Value*)&buffer[sizeof(Key)];
            m_mapTable[*_key] = *_value;
        }
        fclose(fp);
        return (GetFileSize(filename) == (m_mapTable.size()*metasize));
    }

    bool Save(const char* filename)
    {
        FILE* fp = fopen(filename,"wb");
        if (fp ==NULL)
            return false;

        int metasize = sizeof(Key) + sizeof(Value);
        char buffer[sizeof(Key) + sizeof(Value)];

        int  readed;
        Key* _key;
        Value* _value;

        MapStreamIterator iter = m_mapTable.begin();
        while (iter!=m_mapTable.end())
        {
            fwrite(&iter->first, 1,sizeof(Key),fp);
            fwrite(&iter->second,1,sizeof(Value),fp);
            iter++;
        }
        fclose(fp);
        int filesize = GetFileSize(filename);
        return (GetFileSize(filename) == (m_mapTable.size()*metasize));
    }

    Value& operator[] (const Key& _key)
    {
        return m_mapTable[_key];
    }

    Value* GetValue(const Key& _key)
    {
        MapStreamIterator iter  = m_mapTable.find(_key);
        if (iter!=m_mapTable.end())
            return &iter->second;
        return NULL;
    }
    void SetValue(const Key& _key,const Value& _value)
    {
        m_mapTable[_key] = _value;
    }
    void RemoveKey(const Key& _key)
    {
        m_mapTable.erase(_key);
    }
    int Count()
    {
        return m_mapTable.size();
    }
};

天下 2014-04-07 13:52 发表评论

天下 — Wed, 26 Jun 2013 03:51:00 GMT

C++�c�M��模板函数的特�?br />
最�q�在使用在��用模板特�?nbsp;写一�D늨�序时发现一个奇怪的问题�Q�比如像如下代码�Q?br />
     #include <iostream>
using namespace std;
class CMyClass
{
public:
     template <typename T>
     struct test
     {
         T i;
     };

     template <>
     struct test<long>
     {
         unsigned long i;
     };
};

int main(void)
{
     CMyClass::test<int> test1;
     CMyClass::test<long> test2;
     CMyClass::test<char> test3;

     cout << "typeid(test1.i) is " << typeid(test1.i).name() << endl;
     cout << "typeid(test2.i) is " << typeid(test2.i).name() << endl;
     cout << "typeid(test3.i) is " << typeid(test3.i).name() << endl;

     return 0;
}

�q�段代码在Linux下的GCC 3.4.3下无法编译通过�Q�编译时提示错误�Q?br />
xxx.cpp:12: error: invalid explicit specialization before '>' token
xxx.cpp:12: error: explicit specialization in non-namespace scope `class CMyClass'

但在VC6和VC8下都可以�~�译通过�?br />

后翻阅资料，发现有�h提到�Q�C++标准中规定，嵌套�c�L��板在�cȝ��定义中不允许被显�C�特化声明，只允许偏特化�Q?#8220;Explicit template specialization is forbidden for nested classes ”�Q?#8220;As partial template specialization is not forbidden ”�Q�，比如�Q�这样就可以�Q?br />

#include <iostream>
using namespace std;

class CMyClass
{
public:
     template <typename T, typename S = void>
     struct test
     {
         T i;
     };
     template <typename S>
     struct test<long, S>
     {
         unsigned long i;
     };
};
int main(void)
{
     CMyClass::test<int> test1;
     CMyClass::test<long> test2;
     CMyClass::test<char> test3;

     cout << "typeid(test1.i) is " << typeid(test1.i).name() << endl;
     cout << "typeid(test2.i) is " << typeid(test2.i).name() << endl;
     cout << "typeid(test3.i) is " << typeid(test3.i).name() << endl;

     return 0;

}

在上面这�D�代码��用一个无用的模板参数来实��C��偏特代替特化�Q�从而化解了�q�个问题。至于�ؓ什么VC下能够正常编译，�|�上的资料说是VC不符合标�?nbsp;�Q?#8220;MSVC is wrong in this case and g++ correct”�Q�，不过�q�点我尚未在C++标准中找到明文依据�?br />
但是�q�样一来就有个问题�Q�偏特化在VC6下是用BUG的，无法正常使用�Q�也��是说出来的代码��无法兼容VC6。对于VC6�q�样落伍的编译器�Q�兼容它是没有太大的必要�Q�但是回头想惻I��N��要在定义嵌套�c�L��板的特化�Q�就不行了么�Q�必��M��用偏特化来代替么�Q�C++�Ҏ��是如何规定的呢？��阅相关资料后，我找 ��C��{�案�Q�－要把特化的代码写在类定义的外面（要写在namespace下）�Q�如�W�一�D�代码应该写成这��P��


#include <iostream>
using namespace std;

class CMyClass
{
public:
     template <typename T>
     struct test
     {
         int i;
     };
};
template <>
struct CMyClass::test<long>
{
     long i;
};

int main(void)
{
     CMyClass::test<int> test1;
     CMyClass::test<long> test2;
     CMyClass::test<char> test3;

     cout << "typeid(test1.i) is " << typeid(test1.i).name() << endl;
     cout << "typeid(test2.i) is " << typeid(test2.i).name() << endl;
     cout << "typeid(test3.i) is " << typeid(test3.i).name() << endl;

     return 0;
}

�q�样修改后，��可以在GCC下编译通过了，同时�Q�VC6�Q�VC8也都能编译通过�Q?br />
�ȝ��一下吧�Q?br />在C++中，如果要对嵌套�c�L��板进行特化，则要么��用偏特化来替代特化（增加一个无用的模板参数�Q�，要么��?nbsp;特化代码攑֜��c�d��义之外�?br />
同样�?非模板函数具有最高的优先�?br />

转自:http://jeffreyloo.blog.163.com/blog/static/12176167020106171424608/

天下 2013-06-26 11:51 发表评论

模板特化和偏特化

天下 — Wed, 26 Jun 2013 03:38:00 GMT

模板特化和偏特化
C++中的模板分�ؓ�c�L��板和函数模板

·模板的特�?br />
(1)�c�L��板特�?br />有时��Z��需�?针对特定的类�?需要对模板�q�行特化,也就是特�D�处�?例如,stack�c�L��杉K��对bool�c�d��,因�ؓ实际上bool�c�d��只需要一个二�q�制位，��可以对其进行存�?使用一个字或者一个字节都是浪费存储空间的.
template <class T>
class stack {};

template<>
class stack<bool>
{
    //…//
};

上述定义中template < >告诉�~�译器这是一个特化的模板。�ƈ且在声明特化模板之前一定要有非特化的声明！�q�且两个�cȝ��名字是一��L��Q?br />
(2)函数模板的特�?br />看下面的例子
int main()
{
   int highest = mymax(5,10);
   char c = mymax(‘a’, ’z’);
   const char* p1 = “hello”;
   const char* p2 = “world”;
   const char* p = mymax(p1,p2);
   return 0;
}
前面两个mymax都能�q�回正确的结�?而第三个却不�?因�ؓ,此时mymax直接比较两个指针p1 �?nbsp;p2 而不是其指向的内�?
针对�q�种情况,当mymax函数的参数类型�ؓconst char* �?需要特化�?br />template <class T>
T mymax(const T t1, const T t2)
{
    return t1 < t2 ? t2 : t1;
}
template <>
const char* mymax(const char* t1,const char* t2)
{
    return (strcmp(t1,t2) < 0) ? t2 : t1;
}
现在mymax(p1,p2)能够�q�回正确的结果了�?br />
4.模板的偏特化
模板的偏特化是指需要根据模板的某些但不是全部的参数�q�行特化
(1) �c�L��板的偏特�?br />例如c++标准库中的类vector的定�?br />template <class T, class Allocator>
class vector
{
    // … //
};

template <class Allocator>
class vector<bool, Allocator>
{
    //…//
};
�q�个偏特化的例子中，一个参数被�l�定到bool�c�d��Q�而另一个参��C��未绑定需要由用户指定�?br />
(2) 函数模板的偏特化
严格的来��_��函数模板�q�不支持偏特化，但由于可以对函数�q�行重蝲�Q�所以可以达到类��g��c�L��板偏特化的效果�?br />template <class T> void f(T);   (a)
�Ҏ��重蝲规则�Q�对�Q�a�Q�进行重�?br />template < class T> void f(T*);   (b)
如果��（a�Q�称为基模板�Q�那么（b�Q�称为对基模板（a�Q�的重蝲�Q�而非对（a�Q�的偏特化。C++的标准委员会仍在对下一个版本中是否允许函数模板的偏特化�q�行讨论�?br />5.模板特化时的匚w��规则
(1) �c�L��板的匚w��规则
最优化的优于次特化的，��x��板参数最�_��匚w��的具有最高的优先�?br />例子�Q?br />template <class T> class vector
{
    //…//
}; // (a)   普通型
template <class T> class vector<T*>
{
    //…//
}; // (b) �Ҏ��针类型特�?/span>
template <>
class vector <void*>
{
    //…//
}; // (c) 对void*�q�行特化
每个�c�d��都可以用作普通型�Q�a�Q�的参数�Q�但只有指针�c�d��才能用作�Q�b�Q�的参数�Q�而只有void*才能作�ؓ(c)的参�?br />
(2) 函数模板的匹配规�?br />非模板函数具有最高的优先权。如果不存在匚w��的非模板函数的话�Q�那么最匚w��的和最特化的函数具有高优先�?br />例子�Q?br />template <class T> void f(T);   // (d)
template <class T> void f(int, T, double); // (e)
template <class T> void f(T*);   // (f)
template <> void f<int> (int) ; // (g)
void f(double);   // (h)
bool b;
int i;
double d;
f(b); // �?nbsp;T = bool 调用 �Q�d�Q?/span>
f(i,42,d) // �?nbsp;T = int 调用�Q�e�Q?/span>
f(&i) ; // �?nbsp;T = int* 调用�Q�f�Q?/span>
f(d);   //   调用�Q�h�Q?/span>

天下 2013-06-26 11:38 发表评论

天下 — Wed, 26 Jun 2013 03:36:00 GMT

C++ 高��主题之模板特�?br />我们很难写出所有可能被实例化的�c�d��都合适的模板。某些情况下�Q�通用模板定义对于某个�c�d��可能是完全错误的�Q�所以我们需要能够实现处理某些特�D�情况，特化的概念变是如此�?br />compare函数和Queue�c�L��q�个问题的很好例子。因��Z��C风格字符串一起��用时�Q�他们都不能正确工作�?br />template <typename T>
int compare(const T &v1,const T &v2)
{
    if(v1 < v2) return -1;
    if(v2 < v1) return 1;
    return 0;
}
如果用两个const char* 实参调用�q�个模板定义�Q�函数将比较指针的倹{��也��是比较两个指针在内存中的相对位�|�，却�ƈ没有说明与指针所指数�l�的内容有关的�Q何事情�?br />��Z��能够��compare函数用于字符�Ԍ��必须提供一个知道怎样比较C风格字符串的�Ҏ��定义。这些就被称作是特化的，它对模板的用戯��言是透明的�?br />
1. 函数模板的特�?br />特化形式�Q?br />- 关键字template后面接一对空的尖括号<>;
- 再接模板名和一对尖括号<>�Q�尖括号中指定这个特化定义的模板参数�Q?br />- 函数形参�?br />- 函数�?br />template<>
int compare<const char*> (const char* const &v1,const char* const &v2)
{
    return strcmp(v1,v2);
}
特化的声明必��M�� 对应的模板相匚w��。类型�Ş参固定�ؓconst char*�?br />因此�Q�函数�Ş参是const char* 的const引用。当调用compare函数的时候，
传给它两个字�W�指针，�~�译器将调用特化版本。而不调用上面的泛型版本�?br />const  char *cp1 = "world", *cp2 = "hi";
int i1, i2;
compare(cp1, cp2); //调用特化函数模板
compare(i1, i2);  //调用泛型函数模板
注意�Q?br />* 函数模板特化时template<>不能省略�Q�如果缺��结果是声明该函数的重蝲�?br />* 必须包含函数形参列表。如果可以从形参列表推断模板实参�Q�则不必昄��指定模板实参�?br />* 如果�E�序由多个文件构成，模板特化的声明必��d��使用该特化的每个文�g中出现�?br />
2.�c�L��板的特化
当��用C风格字符串时�Q�Queue�c�d��?nbsp;compare函数�怼�的问题。问题就处在push函数中，该函数复制给定的��g��创徏Queue中的新元素。默认情况下�Q�复制C风格字符串只会复制指针，不会复制字符。而显然复制指针将出现一�p�d��的严重问题。�ؓ了解军_��制C风格字符串的问题�Q�需要�ؓconst char*定义整个�cȝ��特化版本:
template<>
class Queue<const char*>
{
public:
    void push(const char*);
    void pop() {real_queue.pop();}
    bool empty() const {return real_queue.front();}
    //�q�回�c�d��与模板参数类型不�?/span>
    std::string front() {return real_queue.front();}
    const std::string &front() const {return real_queue.front();}
private :
    Queue<std::string> real_queue;
};

�l�Queue一个新的数据元�?string对象的Queue。在�cȝ��外部定义一个成�?
void Queue<const char*>::push (const char* val)
{
    return real_queue.push(val);
}
�q�个函数通过调用read_queue的push函数把val指向的数�l�复制到未命名的string 对象中。当需要出队列的时候调用相应real_queue.pop()函数卌��回了�q�个string�Q�从而解决了不用复制指针的问题�?br />
3.特化成员而不特化�c�d��上例的实��C��Q�我们可以换一�U�方法，即不需要特化类�Q�而只需要特化类的成员函数push、pop。根据函数模板特化的要求�Q?br />template <>
void Queue<const char*>::push(const char *const &val)
{
    char * new_item = new char[strlen(val)+1];
    strncpy(new_item, val, strlen(val)+1);
    QueueItem<const char*> *pt = new QueueItem<const char*>(new_item);

    if(empty())
        head = tail = pt;  //队列中没有元�?/span>
    eles{
        tail->next = pt; //��d��新元素到列尾
        tail = pt;
    }
}
template<>
void Queue<const char*>::pop()
{
    QueueItem<const char*> *p = head;
    delete head->item;  //删除队首元素
    head = head->next;  //指向当前队首元素
    delete p;            //删除零时指针
}

4.�c�L��板的部分特化
    如果�c�L��板有一个以上的模板形参�Q�我们很有可能只要特化某些模板�Ş�?br />    而不是全部�Ş参。这时我们就需要��用类的部分特化�?br />//定义模板�c?/span>
template <class T1, class T2>
class some_template{
    //
};

//定义模板�cȝ��部分特化�Q�T2�c�d��固定�Q�部分特化T1�c�d��
template<class T1>
class some_template<T1, int>{
    //
};
//使用�c�L��板的部分特化
some_template<int, string> foo; //使用模板�c?/span>
some_template<string,int> bar;  //使用模板�cȝ��部分特化
通过使用模板特化能解决一些在通常或者通用情况下无法解决的�Ҏ��问题。在掌握了基本的语法规范和实现方法后便可以加以应用�?/span>

天下 2013-06-26 11:36 发表评论

模板特化

天下 — Tue, 07 Feb 2012 06:45:00 GMT

#include <cstdio>
#include <cstring>

template <class T>
T mymax(const T t1, const T t2)
{
    return t1 < t2 ? t2 : t1;
}

//模板特化
//特化为绝对类�?br />//上述定义中template < >告诉�~�译器这是一个特化的模板。�ƈ且在声明特化模板之前一定要有非特化的声明！�q�且两个�cȝ��名字是一��L��Q?br />//特化的模板必��L��在非特化的模板的之后
//否则�~�译器死�l�你�?如下:
//'const char *mymax(const char *,const char *)' is not a specialization of a function template

template<>
const char* mymax(const char* t1,const char* t2)
{
    return (strcmp(t1,t2) < 0) ? t2 : t1;
}

/*
非模板函�?br />非模板函数具有最高的优先�?br />const char* mymax(const char* t1,const char* t2)
{
    return (strcmp(t1,t2) < 0) ? t2 : t1;
}
*/

int main()
{
    int highest = mymax(5,10);
    char c = mymax('a', 'z');
    const char* p1 = "hello";
    const char* p2 = "world";
    const char* p = mymax(p1,p2);
    return 0;
}

天下 2012-02-07 14:45 发表评论