李老师群课之再谈元编程

只看该作者 · 2013-8-29 15:49

其实，古董对于有钱人也许值钱，对于一个叫花子，不能吃不能穿。不是垃圾是什么？李老师的代码也是如此。在需要的人眼里是好东西，在不需要的人眼里，一无用处，当然认为是垃圾了。

只看该作者 · 2013-8-29 18:39

乡村男孩发表于 2013-8-29 15:45
如果你认为是垃圾请指出垃圾之处，如果大家都认为你说得有理，那才是真正的交流，而不是无理放纵，如果客 ...

给你10000行这种代码让你维护，你试试~~~？？就这程序10000行中出1个Bug看能不能弄死维护的人，维护的人每天骂死你。你编写的程序是要给其它人看的，要有继承性，有规范性，可维护！这种程序都是为了显示自己水平搞出来的。如果你要真有水平请把程序的详细设计的流程图给出来，看有几个人拿着你的流程图不会编程？所以不要把垃圾拿出来看！

只看该作者 · 2013-8-29 22:45

haiyuan254 发表于 2013-8-29 18:39
给你10000行这种代码让你维护，你试试~~~？？就这程序10000行中出1个Bug看能不能弄死维护的人，维护的人 ...

人家是举例讲方法，看不明白就说人家垃圾，一点条理也没有
还以为你能贴出更好的代码来让我们欣赏呢

只看该作者 · 2013-8-29 22:51

唉，一万行代码要怎么写才好维护？一万行汇编？一万行A？一万行B？一万行C？一万行C++？一万行C#？我觉得都好难。给我1000行我都觉得难。我只想维护100行。最好是还拿着高薪并且不干活。

只看该作者 · 2013-9-4 09:25

:L if i am not coding，then i am debugging；i have no time to think of this

1万 · 2013-9-6 16:10

丧失了c++的可读性.低等代码....

我写过十万行c++,也没写过这么难读的东西

只看该作者 · 2013-9-6 21:38

icecut 发表于 2013-9-6 16:10
丧失了c++的可读性.低等代码....

我写过十万行c++,也没写过这么难读的东西

十万行，不错，那倒要请教一下了，下面这段是不是你所谓的低等代码：

复制

template<std::size_t _Idx, typename _Head, typename... _Tail>

struct _Tuple_impl<_Idx, _Head, _Tail...>

: public _Tuple_impl<_Idx + 1, _Tail...>,

  private _Head_base<_Idx, _Head, __empty_not_final<_Head>::value>

{

  template<std::size_t, typename...> friend class _Tuple_impl;



  typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;

  typedef _Head_base<_Idx, _Head, __empty_not_final<_Head>::value> _Base;



  static constexpr _Head&  

  _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }



  static constexpr const _Head&

  _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }



  static constexpr _Inherited&

  _M_tail(_Tuple_impl& __t) noexcept { return __t; }



  static constexpr const _Inherited&

  _M_tail(const _Tuple_impl& __t) noexcept { return __t; }



  constexpr _Tuple_impl()

  : _Inherited(), _Base() { }



  explicit 

  constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)

  : _Inherited(__tail...), _Base(__head) { }



  template<typename _UHead, typename... _UTail, typename = typename

           enable_if<sizeof...(_Tail) == sizeof...(_UTail)>::type> 

    explicit

    constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)

    : _Inherited(std::forward<_UTail>(__tail)...),

      _Base(std::forward<_UHead>(__head)) { }



  constexpr _Tuple_impl(const _Tuple_impl&) = default;



  constexpr

  _Tuple_impl(_Tuple_impl&& __in)

  noexcept(__and_<is_nothrow_move_constructible<_Head>,

                  is_nothrow_move_constructible<_Inherited>>::value)

  : _Inherited(std::move(_M_tail(__in))), 

    _Base(std::forward<_Head>(_M_head(__in))) { }



  template<typename... _UElements>

    constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)

    : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),

      _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }



  template<typename _UHead, typename... _UTails>

    constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)

    : _Inherited(std::move

                 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),

      _Base(std::forward<_UHead>

            (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }



  template<typename _Alloc>

    _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)

    : _Inherited(__tag, __a),

      _Base(__use_alloc<_Head>(__a)) { }



  template<typename _Alloc>

    _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,

                const _Head& __head, const _Tail&... __tail)

    : _Inherited(__tag, __a, __tail...),

      _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }



  template<typename _Alloc, typename _UHead, typename... _UTail,

           typename = typename enable_if<sizeof...(_Tail)

                                         == sizeof...(_UTail)>::type>

    _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,

                _UHead&& __head, _UTail&&... __tail)

    : _Inherited(__tag, __a, std::forward<_UTail>(__tail)...),

      _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),

            std::forward<_UHead>(__head)) { }



  template<typename _Alloc>

    _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,

                const _Tuple_impl& __in)

    : _Inherited(__tag, __a, _M_tail(__in)), 

      _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }



  template<typename _Alloc>

    _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,

                _Tuple_impl&& __in)

    : _Inherited(__tag, __a, std::move(_M_tail(__in))), 

      _Base(__use_alloc<_Head, _Alloc, _Head>(__a),

            std::forward<_Head>(_M_head(__in))) { }



  template<typename _Alloc, typename... _UElements>

    _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,

                const _Tuple_impl<_Idx, _UElements...>& __in)

    : _Inherited(__tag, __a,

                 _Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),

      _Base(__use_alloc<_Head, _Alloc, _Head>(__a),

            _Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }



  template<typename _Alloc, typename _UHead, typename... _UTails>

    _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,

                _Tuple_impl<_Idx, _UHead, _UTails...>&& __in)

    : _Inherited(__tag, __a, std::move

                 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),

      _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),

            std::forward<_UHead>

            (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }



  _Tuple_impl&

  operator=(const _Tuple_impl& __in)

  {

    _M_head(*this) = _M_head(__in);

    _M_tail(*this) = _M_tail(__in);

    return *this;

  }



  _Tuple_impl&

  operator=(_Tuple_impl&& __in)

  noexcept(__and_<is_nothrow_move_assignable<_Head>,

                  is_nothrow_move_assignable<_Inherited>>::value)

  {

    _M_head(*this) = std::forward<_Head>(_M_head(__in));

    _M_tail(*this) = std::move(_M_tail(__in));

    return *this;

  }



  template<typename... _UElements>

    _Tuple_impl&

    operator=(const _Tuple_impl<_Idx, _UElements...>& __in)

    {

      _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in);

      _M_tail(*this) = _Tuple_impl<_Idx, _UElements...>::_M_tail(__in);

      return *this;

    }



  template<typename _UHead, typename... _UTails>

    _Tuple_impl&

    operator=(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)

    {

      _M_head(*this) = std::forward<_UHead>

        (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));

      _M_tail(*this) = std::move

        (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in));

      return *this;

    }



protected:

  void

  _M_swap(_Tuple_impl& __in)

  noexcept(noexcept(swap(std::declval<_Head&>(),

                         std::declval<_Head&>()))

           && noexcept(_M_tail(__in)._M_swap(_M_tail(__in))))

  {

    using std::swap;

    swap(_M_head(*this), _M_head(__in));

    _Inherited::_M_swap(_M_tail(__in));

  }

};

1万 · 2013-9-6 23:32

我说你可读性差.对于应用就是低等代码.
你复制那段代码做基础代码平台代码都没问题,就是不能做应用层.明白?
不要弄个stdc++的lib来忽悠大家.
我们写的是application,不是lib,不一样的思路的.把大家忽悠傻了不好.
上面代码我不认识.百度不可能不认识,谷歌不可能不认识,因为我一看就不是你自己写的.

只看该作者 · 2013-9-7 00:36

icecut 发表于 2013-9-6 23:32
我说你可读性差.对于应用就是低等代码.
你复制那段代码做基础代码平台代码都没问题,就是不能做应用层.明白? ...

你从哪儿看出来我写的这段代码是应用层的？

复制

namespace crc32 {

template <uint32_t CRC, uint8_t BIT = 0>

struct byte : byte <(CRC >> 1) ^ (-int32_t (CRC & 1) & 0xedb88320), BIT + 1> { };



template <uint32_t CRC>

struct byte <CRC, 8> { uint32_t value{ CRC }; };



template <uint16_t I = 0>

struct array : byte <I>, array <I + 1> { };



template <>

struct array <256> { };



struct table : private array <> {

  const uint32_t& operator [] (int i) const

  {

    return reinterpret_cast<const uint32_t*>(this);

  }

};

}

如果你不知道，那我告诉你，这段代码是生成 crc32 的查找表，你觉得应该放在基础代码还是应用代码？
再者，这段代码，是为了讲解C++元编程而写的示例程序，后面有详细的讨论，你说要怎么写才可读性好？要不你来写个让我学习一下？

只看该作者 · 2013-9-7 10:56

icecut 发表于 2013-9-6 23:32
我说你可读性差.对于应用就是低等代码.
你复制那段代码做基础代码平台代码都没问题,就是不能做应用层.明白? ...

  有争议啊，呵呵。有些东西本来就是仁者见仁智者见智，但乱贴标签却不是技术人员该有的态度。不调查就没有发言权。这是讲元编程的，建议了解一下c++元编程。
  c++最新的标准是C++11，http://zh.wikipedia.org/wiki/C%2B%2B11，这里有详细的介绍。和C相比，C++对技术人员的软件功底要求更高。class好理解，泛型，就不那么容易了。元编程理解起来更困难。
  C++能写出更加优雅的代码，不过，也得看阅读者的功底了，以下代码摘自老师的lestl 的sfr.hpp（先声明：版权属于john lee老师所有）,我觉得非常的巧妙，不知道你觉得如何？

复制

/*

  Copyright (c) 2012-2013  John Lee (j.y.lee@yeah.net)

  All rights reserved.



  Redistribution and use in source and binary forms, with or without

  modification, are permitted provided that the following conditions are met:



  * Redistributions of source code must retain the above copyright

  notice, this list of conditions and the following disclaimer.



  * Redistributions in binary form must reproduce the above copyright

  notice, this list of conditions and the following disclaimer in

  the documentation and/or other materials provided with the

  distribution.



  * Neither the name of the copyright holders nor the names of

  contributors may be used to endorse or promote products derived

  from this software without specific prior written permission.



  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE

  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN If ADVISED OF THE

  POSSIBILITY OF SUCH DAMAGE.

*/



#ifndef __LESTL_SFR_HPP

#define __LESTL_SFR_HPP



#include <cstdint>

#include <attribute.h>



namespace sfr {

template <typename R, uint8_t S, uint8_t W>

struct sfb_t {                      // Special Function Bit

  enum {

    LSB = S,

    WIDTH = W,

    MASK = (((1LL << W) - 1) << S)

  };



  __INLINE sfb_t () {}

  __INLINE uintptr_t

  lsb ()

  { return LSB; }



  __INLINE uintptr_t

  lsb () const

  { return LSB; }



  __INLINE uintptr_t

  width ()

  { return WIDTH; }



  __INLINE uintptr_t

  width () const

  { return WIDTH; }



  __INLINE typename R::type

  mask ()

  { return MASK; }



  __INLINE typename R::type

  mask () const

  { return MASK; }



  __INLINE typename R::type

  read ()

  { return (reinterpret_cast<R*>(this)->val & MASK) >> LSB; }



  __INLINE typename R::type

  read () const

  { return (reinterpret_cast<const R*>(this)->val & MASK) >> LSB; }



  __INLINE operator typename R::type ()

  { return read (); }



  __INLINE operator typename R::type () const

  { return read (); }



  __INLINE R&

  read (typename R::type& v)

  {

    v = read ();

    return *reinterpret_cast<R*>(this);

  }



  __INLINE R&

  read (typename R::type& v) const

  {

    v = read ();

    return *reinterpret_cast<R*>(this);

  }



  __INLINE R&

  write (typename R::type v, bool safe = true)

  {

    register R* p = reinterpret_cast<R*>(this);

    typename R::type _v = v;

    p->changed |= MASK;

    _v <<= LSB;

    if (!__builtin_constant_p (v)

        || ((~_v & MASK) != 0 && (p->zero_mask & MASK) != 0))

      p->val &= ~MASK;

    if (safe)

      _v &= MASK;

    p->val |= _v;

    p->zero_mask |= __builtin_constant_p (v) ? _v : (~0 & MASK);

    return *p;

  }



  __INLINE R&

  operator () (typename R::type v, bool safe = true)

  { return write (v, safe); }



  __INLINE R&

  operator = (typename R::type v)

  { return write (v, true).apply (); }



  template <typename T>

  __INLINE R&

  lambda (T v)

  {

    register R* p = reinterpret_cast<R*>(this);                //强制类型转换

    register typename R::type data = (p->val & MASK) >> LSB;        //读取位域

    register auto res = v (data);

    if (data != res)

      write (res);

    return *p;

  }



  template <typename T>

  __INLINE R&

  lambda (T v) const

  {

    register R* p = reinterpret_cast<R*>(this);

    register typename R::type data = (p->val & MASK) >> LSB;

    register auto res = v (data);

    return *p;

  }



  __INLINE R&

  operator &= (typename R::type v)

  {

    register R* p = reinterpret_cast<R*>(this);

    register typename R::type data = (v << LSB) | ~MASK;

    if (data != typename R::type (~0)) {

      p->changed |= MASK;

      p->val &= data;

    }

    return *p;

  }



  __INLINE R&

  operator ^= (typename R::type v)

  {

    register R* p = reinterpret_cast<R*>(this);

    if (v != 0) {

      p->changed |= MASK;

      p->val ^= (v << LSB) & MASK;

    }

    return *p;

  }



  __INLINE R&

  rol (uint_fast8_t n)

  {

    register R* p = reinterpret_cast<R*>(this);

    p->changed |= MASK;

    register typename R::type v = p->val & MASK;

    p->val &= ~MASK;

    p->val |= ((v << n) | (v >> W - n)) & MASK;

    return *p;

  }



  __INLINE R&

  ror (uint_fast8_t n)

  {

    return rol(W - n);

  }

};



template <typename SFR>

class sfr_t {                       // Special Function Register

public:

  __INLINE constexpr sfr_t () { }

  __INLINE sfr_t (typename SFR::type v) : val{ v } { }

  __INLINE operator typename SFR::type () { return val; }

  __INLINE operator typename SFR::type () const { return val; }

  __INLINE operator typename SFR::type () volatile { return val; }

  __INLINE operator typename SFR::type () const volatile { return val; }



  __INLINE sfr_t <SFR>

  operator = (SFR v)

  {

    val = v.val;

    return *this;

  }



  __INLINE sfr_t <SFR>

  operator = (SFR v) volatile

  {

    val = v.val;

    return *this;

  }



  __INLINE typename SFR::type

  operator = (typename SFR::type v)

  {

    val = v;

    return v;

  }



  __INLINE typename SFR::type

  operator = (typename SFR::type v) volatile

  {

    val = v;

    return v;

  }



  __INLINE SFR operator () () { return SFR (val); }

  __INLINE SFR operator () () const { return SFR (val); }

  __INLINE SFR operator () () volatile { return SFR (val); }

  __INLINE SFR operator () () const volatile { return SFR (val); }

  __INLINE SFR operator () (typename SFR::type v) { return SFR (val, v); }

  __INLINE SFR

  operator () (typename SFR::type v) volatile

  { return SFR (val, v); }



  volatile typename SFR::type val;

};

}



#define __SFR(SFR, TYPE, WRITE)                                     \

  typedef TYPE type;                                                \

  __INLINE SFR (type volatile& r)                                   \

  : ref(r), val(r), changed(0), zero_mask(~0) { }                   \

  __INLINE SFR (type const volatile& r)                             \

  : ref(const_cast<type volatile&>(r)), val(r),                     \

    changed(0), zero_mask(~0) { }                                   \

  __INLINE SFR (type volatile& r, type v)                           \

  : ref(r), val(v), changed(~0),                                    \

    zero_mask(__builtin_constant_p (v) ? v : ~0) { }                \

  __INLINE ~SFR ()                                                  \

  {                                                                 \

    if (changed != 0)                                               \

      apply ();                                                     \

  }                                                                 \

  template <uint8_t S, uint8_t W>                                   \

  __INLINE sfr::sfb_t <SFR, S, W>& field ()                         \

  {                                                                 \

    return *reinterpret_cast<sfr::sfb_t <SFR, S, W>*>(this);        \

  }                                                                 \

  __INLINE SFR& apply ()                                            \

  {                                                                 \

    if ((WRITE & 1) != 0 && (changed & 0xffffff00) == 0)            \

      reinterpret_cast<volatile uint8_t*>(&ref)[0] = val;           \

    else if ((WRITE & 1) != 0 && (changed & 0xffff00ff) == 0)       \

      reinterpret_cast<volatile uint8_t*>(&ref)[1] = val >> 8;      \

    else if ((WRITE & 1) != 0 && (changed & 0xff00ffff) == 0)       \

      reinterpret_cast<volatile uint8_t*>(&ref)[2] = val >> 16;     \

    else if ((WRITE & 1) != 0 && (changed & 0x00ffffff) == 0)       \

      reinterpret_cast<volatile uint8_t*>(&ref)[3] = val >> 24;     \

    else if ((WRITE & 2) != 0 && (changed & 0xffff0000) == 0)       \

      reinterpret_cast<volatile uint16_t*>(&ref)[0] = val;          \

    else if ((WRITE & 2) != 0 && (changed & 0xffff) == 0)           \

      reinterpret_cast<volatile uint16_t*>(&ref)[1] = val >> 16;    \

    else                                                            \

      ref = val;                                                    \

    __asm__ __volatile__("" ::: "memory");                          \

    changed = 0;                                                    \

    return *this;                                                   \

  }                                                                 \

  struct {                                                          \

    type volatile& ref;                                             \

    type val;                                                       \

    type changed;                                                   \

    type zero_mask;                                                 \

  };



#endif  // __LESTL_SFR_HPP

只看该作者 · 2013-9-7 11:04

那家伙，居然说代码是老师复制贴粘过来的，真是无语了，是他以自个的水平去揣摩别人的水平，这也太自以为是了，真是井底之蛙，Lee老师别跟他这种人计较！

1万 · 2013-9-7 15:41

如果c++变成这个样子,我想c++ primer之类的书就可以点火烧了....

1万 · 2013-9-7 16:11

c++元编程真不是你这么玩的.....

送你四个字:邯郸学步

只看该作者 · 2013-9-7 16:43

icecut 发表于 2013-9-7 16:11
c++元编程真不是你这么玩的.....

送你四个字:邯郸学步

这东西诞生之初很多人，甚至包括Bjarne Strou-strup，都认为是“过于聪明”的东西。结果经过多年的演变，诞生出了一批相当优秀的库。至今为止，这玩意还处于半学术研究状态，各种磕磕绊绊自然是少不了。
按你的意思就是，不能做应用层，那就是垃圾。这样想，你永远只是做一些简单的应用层。
在我看来，邯郸学步的人是有未来的，固步自封的人一辈子也就那么回事了。

PS：说实话，C++ primer这书已经有点跟不上时代了。

只看该作者 · 2013-9-7 17:26

haiyuan254 发表于 2013-8-29 18:39
给你10000行这种代码让你维护，你试试~~~？？就这程序10000行中出1个Bug看能不能弄死维护的人，维护的人 ...

虽然确实很容易被滥用，但元编程是基础库的一个利器。能维护基础库的人本来就很少，Boost里的代码比这热闹多了，那也是垃圾？写那些代码的人哪个都不是省油的灯。关键在于，总有些问题本身就足够复杂，以至于必须用复杂的代码才能表达。

天天写随便抓个人就能维护的代码，意味着你永远没有机会接触只有少数人才能维护的代码，你的水平也就永远停留在大众的水平了。

只看该作者 · 2013-9-7 17:36

icecut 发表于 2013-9-7 16:11
c++元编程真不是你这么玩的.....

送你四个字:邯郸学步

你这算回答我的问题了吗？我看是逃避问题、转移话题或者根本就是理屈词穷。

1万 · 2013-9-7 20:51

本帖最后由 icecut 于 2013-9-7 21:03 编辑

kseeker 发表于 2013-9-7 16:43
这东西诞生之初很多人，甚至包括Bjarne Strou-strup，都认为是“过于聪明”的东西。结果经过多年的演变， ...

说的很对.是优秀的库.这种东西就是做库的.

不能做应用层.在国内就不能创造更大的收益.
这些东西留给老外去用.

1万 · 2013-9-7 20:51

kseeker 发表于 2013-9-7 17:26
虽然确实很容易被滥用，但元编程是基础库的一个利器。能维护基础库的人本来就很少，Boost里的代码比这热 ...

此种编程技巧能写出优美、简洁的代码; 然而除错是此种编程技巧的弱处: 编译期的错误信息让人不知所云，运行期的除错更是困难。来自:http://zh.wikipedia.org/wiki/C%2B%2B11

1万 · 2013-9-7 20:52

john_lee 发表于 2013-9-7 17:36
你这算回答我的问题了吗？我看是逃避问题、转移话题或者根本就是理屈词穷。 ...

我回复你的是你给我贴的代码,你然后写个crc,你已经歪曲概念了,我理你是没有意义的.

只看该作者 · 2013-9-7 22:11

icecut 发表于 2013-9-7 20:52
我回复你的是你给我贴的代码,你然后写个crc,你已经歪曲概念了,我理你是没有意义的. ...

请直接回答我贴的这段crc代码不算你所谓的“低级代码”？

如果算，那么你来写个“高级代码”让我们瞧一瞧，比一比；记住，功能不能变，也必须是编译时生成crc32查找表。如果你写不出，那么请不要对你不懂的知识妄加评论，否则会成为笑柄的。
如果不算，你所说的“低级代码”就是指楼主位贴子里的代码了，那么拜托你把眼镜擦擦，看清楚一点，我贴的这段crc代码，正是转自楼主位贴子里的。你连帖子都不认真看就妄加评论，还是免不了成为笑柄的。

李老师群课之 再谈元编程

精英会员奖章

沉静之湖泊

技术导师奖章

缘定三生

经常做客

技术新星奖章

无冕之王奖章

十世金身

技术奇才奖章

以坛为家

晶莹之水滴

技术领袖奖章

荣誉元老奖章

坚毅之洋流

技术高手奖章

常驻人口

李老师群课之再谈元编程