21ic电子技术开发论坛 › 已关闭版块 › Cortex-M0助学园地 › 李老师群课之 再谈元编程
1234下一页
返回列表 发新帖我要提问

[LOOK] 李老师群课之 再谈元编程

[复制链接]
11600|79
缥缈九哥 发表于 2013-8-29 15:49 | 显示全部楼层
其实，古董对于有钱人也许值钱，对于一个叫花子，不能吃不能穿。不是垃圾是什么？李老师的代码也是如此。在需要的人眼里是好东西，在不需要的人眼里，一无用处，当然认为是垃圾了。
回复

收藏 举报

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

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

收藏 举报

评论

icecut
严重同意...  发表于 2013-9-7 15:43
aihe 发表于 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行。最好是还拿着高薪并且不干活。
回复

收藏 举报

评论

icecut
连这个都不知道怎么写可维护,你还是先去看书吧.别闭门造车了.推荐<重构-改善既有代码的设计>  发表于 2013-9-7 15:44
zhangli019 发表于 2013-9-4 09:25 | 显示全部楼层
:L if i am not coding，then i am debugging；i have no time to think of this
回复

收藏 举报

icecut 发表于 2013-9-6 16:10 | 显示全部楼层
丧失了c++的可读性.低等代码....

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

收藏 举报

john_lee 发表于 2013-9-6 21:38 | 显示全部楼层
icecut 发表于 2013-9-6 16:10
丧失了c++的可读性.低等代码....

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

十万行，不错，那倒要请教一下了，下面这段是不是你所谓的低等代码：
复制
  1. template<std::size_t _Idx, typename _Head, typename... _Tail>
    

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

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

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

  5. {
    

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


  7. 

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

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


  10. 

  11.   static constexpr _Head&  
    

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


  13. 

  14.   static constexpr const _Head&
    

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


  16. 

  17.   static constexpr _Inherited&
    

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


  19. 

  20.   static constexpr const _Inherited&
    

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


  22. 

  23.   constexpr _Tuple_impl()
    

  24.   : _Inherited(), _Base() { }
    


  25. 

  26.   explicit 
    

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

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


  29. 

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

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

  32.     explicit
    

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

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

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


  36. 

  37.   constexpr _Tuple_impl(const _Tuple_impl&) = default;
    


  38. 

  39.   constexpr
    

  40.   _Tuple_impl(_Tuple_impl&& __in)
    

  41.   noexcept(__and_<is_nothrow_move_constructible<_Head>,
    

  42.                   is_nothrow_move_constructible<_Inherited>>::value)
    

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

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


  45. 

  46.   template<typename... _UElements>
    

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

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

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


  50. 

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

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

  53.     : _Inherited(std::move
    

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

  55.       _Base(std::forward<_UHead>
    

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


  57. 

  58.   template<typename _Alloc>
    

  59.     _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
    

  60.     : _Inherited(__tag, __a),
    

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


  62. 

  63.   template<typename _Alloc>
    

  64.     _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
    

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

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

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


  68. 

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

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

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

  72.     _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
    

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

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

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

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


  77. 

  78.   template<typename _Alloc>
    

  79.     _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
    

  80.                 const _Tuple_impl& __in)
    

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

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


  83. 

  84.   template<typename _Alloc>
    

  85.     _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
    

  86.                 _Tuple_impl&& __in)
    

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

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

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


  90. 

  91.   template<typename _Alloc, typename... _UElements>
    

  92.     _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
    

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

  94.     : _Inherited(__tag, __a,
    

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

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

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


  98. 

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

  100.     _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
    

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

  102.     : _Inherited(__tag, __a, std::move
    

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

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

  105.             std::forward<_UHead>
    

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


  107. 

  108.   _Tuple_impl&
    

  109.   operator=(const _Tuple_impl& __in)
    

  110.   {
    

  111.     _M_head(*this) = _M_head(__in);
    

  112.     _M_tail(*this) = _M_tail(__in);
    

  113.     return *this;
    

  114.   }
    


  115. 

  116.   _Tuple_impl&
    

  117.   operator=(_Tuple_impl&& __in)
    

  118.   noexcept(__and_<is_nothrow_move_assignable<_Head>,
    

  119.                   is_nothrow_move_assignable<_Inherited>>::value)
    

  120.   {
    

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

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

  123.     return *this;
    

  124.   }
    


  125. 

  126.   template<typename... _UElements>
    

  127.     _Tuple_impl&
    

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

  129.     {
    

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

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

  132.       return *this;
    

  133.     }
    


  134. 

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

  136.     _Tuple_impl&
    

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

  138.     {
    

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

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

  141.       _M_tail(*this) = std::move
    

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

  143.       return *this;
    

  144.     }
    


  145. 

  146. protected:
    

  147.   void
    

  148.   _M_swap(_Tuple_impl& __in)
    

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

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

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

  152.   {
    

  153.     using std::swap;
    

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

  155.     _Inherited::_M_swap(_M_tail(__in));
    

  156.   }
    

  157. };
回复

收藏 举报

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

回复

收藏 举报

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

你从哪儿看出来我写的这段代码是应用层的？
复制
  1. namespace crc32 {
    

  2. template <uint32_t CRC, uint8_t BIT = 0>
    

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


  4. 

  5. template <uint32_t CRC>
    

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


  7. 

  8. template <uint16_t I = 0>
    

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


  10. 

  11. template <>
    

  12. struct array <256> { };
    


  13. 

  14. struct table : private array <> {
    

  15.   const uint32_t& operator [] (int i) const
    

  16.   {
    

  17.     return reinterpret_cast<const uint32_t*>(this);
    

  18.   }
    

  19. };
    

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

收藏 举报

 楼主| mahui843 发表于 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老师所有）,我觉得非常的巧妙，不知道你觉得如何？
复制
  1. /*
    

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

  3.   All rights reserved.
    


  4. 

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

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


  7. 

  8.   * Redistributions of source code must retain the above copyright
    

  9.   notice, this list of conditions and the following disclaimer.
    


  10. 

  11.   * Redistributions in binary form must reproduce the above copyright
    

  12.   notice, this list of conditions and the following disclaimer in
    

  13.   the documentation and/or other materials provided with the
    

  14.   distribution.
    


  15. 

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

  17.   contributors may be used to endorse or promote products derived
    

  18.   from this software without specific prior written permission.
    


  19. 

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

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

  22.   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    

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

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

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

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

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

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

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

  30.   POSSIBILITY OF SUCH DAMAGE.
    

  31. */
    


  32. 

  33. #ifndef __LESTL_SFR_HPP
    

  34. #define __LESTL_SFR_HPP
    


  35. 

  36. #include <cstdint>
    

  37. #include <attribute.h>
    


  38. 

  39. namespace sfr {
    

  40. template <typename R, uint8_t S, uint8_t W>
    

  41. struct sfb_t {                      // Special Function Bit
    

  42.   enum {
    

  43.     LSB = S,
    

  44.     WIDTH = W,
    

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

  46.   };
    


  47. 

  48.   __INLINE sfb_t () {}
    

  49.   __INLINE uintptr_t
    

  50.   lsb ()
    

  51.   { return LSB; }
    


  52. 

  53.   __INLINE uintptr_t
    

  54.   lsb () const
    

  55.   { return LSB; }
    


  56. 

  57.   __INLINE uintptr_t
    

  58.   width ()
    

  59.   { return WIDTH; }
    


  60. 

  61.   __INLINE uintptr_t
    

  62.   width () const
    

  63.   { return WIDTH; }
    


  64. 

  65.   __INLINE typename R::type
    

  66.   mask ()
    

  67.   { return MASK; }
    


  68. 

  69.   __INLINE typename R::type
    

  70.   mask () const
    

  71.   { return MASK; }
    


  72. 

  73.   __INLINE typename R::type
    

  74.   read ()
    

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


  76. 

  77.   __INLINE typename R::type
    

  78.   read () const
    

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


  80. 

  81.   __INLINE operator typename R::type ()
    

  82.   { return read (); }
    


  83. 

  84.   __INLINE operator typename R::type () const
    

  85.   { return read (); }
    


  86. 

  87.   __INLINE R&
    

  88.   read (typename R::type& v)
    

  89.   {
    

  90.     v = read ();
    

  91.     return *reinterpret_cast<R*>(this);
    

  92.   }
    


  93. 

  94.   __INLINE R&
    

  95.   read (typename R::type& v) const
    

  96.   {
    

  97.     v = read ();
    

  98.     return *reinterpret_cast<R*>(this);
    

  99.   }
    


  100. 

  101.   __INLINE R&
    

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

  103.   {
    

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

  105.     typename R::type _v = v;
    

  106.     p->changed |= MASK;
    

  107.     _v <<= LSB;
    

  108.     if (!__builtin_constant_p (v)
    

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

  110.       p->val &= ~MASK;
    

  111.     if (safe)
    

  112.       _v &= MASK;
    

  113.     p->val |= _v;
    

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

  115.     return *p;
    

  116.   }
    


  117. 

  118.   __INLINE R&
    

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

  120.   { return write (v, safe); }
    


  121. 

  122.   __INLINE R&
    

  123.   operator = (typename R::type v)
    

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


  125. 

  126.   template <typename T>
    

  127.   __INLINE R&
    

  128.   lambda (T v)
    

  129.   {
    

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

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

  132.     register auto res = v (data);
    

  133.     if (data != res)
    

  134.       write (res);
    

  135.     return *p;
    

  136.   }
    


  137. 

  138.   template <typename T>
    

  139.   __INLINE R&
    

  140.   lambda (T v) const
    

  141.   {
    

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

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

  144.     register auto res = v (data);
    

  145.     return *p;
    

  146.   }
    


  147. 

  148.   __INLINE R&
    

  149.   operator &= (typename R::type v)
    

  150.   {
    

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

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

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

  154.       p->changed |= MASK;
    

  155.       p->val &= data;
    

  156.     }
    

  157.     return *p;
    

  158.   }
    


  159. 

  160.   __INLINE R&
    

  161.   operator ^= (typename R::type v)
    

  162.   {
    

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

  164.     if (v != 0) {
    

  165.       p->changed |= MASK;
    

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

  167.     }
    

  168.     return *p;
    

  169.   }
    


  170. 

  171.   __INLINE R&
    

  172.   rol (uint_fast8_t n)
    

  173.   {
    

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

  175.     p->changed |= MASK;
    

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

  177.     p->val &= ~MASK;
    

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

  179.     return *p;
    

  180.   }
    


  181. 

  182.   __INLINE R&
    

  183.   ror (uint_fast8_t n)
    

  184.   {
    

  185.     return rol(W - n);
    

  186.   }
    

  187. };
    


  188. 

  189. template <typename SFR>
    

  190. class sfr_t {                       // Special Function Register
    

  191. public:
    

  192.   __INLINE constexpr sfr_t () { }
    

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

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

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

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

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


  198. 

  199.   __INLINE sfr_t <SFR>
    

  200.   operator = (SFR v)
    

  201.   {
    

  202.     val = v.val;
    

  203.     return *this;
    

  204.   }
    


  205. 

  206.   __INLINE sfr_t <SFR>
    

  207.   operator = (SFR v) volatile
    

  208.   {
    

  209.     val = v.val;
    

  210.     return *this;
    

  211.   }
    


  212. 

  213.   __INLINE typename SFR::type
    

  214.   operator = (typename SFR::type v)
    

  215.   {
    

  216.     val = v;
    

  217.     return v;
    

  218.   }
    


  219. 

  220.   __INLINE typename SFR::type
    

  221.   operator = (typename SFR::type v) volatile
    

  222.   {
    

  223.     val = v;
    

  224.     return v;
    

  225.   }
    


  226. 

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

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

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

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

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

  232.   __INLINE SFR
    

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

  234.   { return SFR (val, v); }
    


  235. 

  236.   volatile typename SFR::type val;
    

  237. };
    

  238. }
    


  239. 

  240. #define __SFR(SFR, TYPE, WRITE)                                     \
    

  241.   typedef TYPE type;                                                \
    

  242.   __INLINE SFR (type volatile& r)                                   \
    

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

  244.   __INLINE SFR (type const volatile& r)                             \
    

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

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

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

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

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

  250.   __INLINE ~SFR ()                                                  \
    

  251.   {                                                                 \
    

  252.     if (changed != 0)                                               \
    

  253.       apply ();                                                     \
    

  254.   }                                                                 \
    

  255.   template <uint8_t S, uint8_t W>                                   \
    

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

  257.   {                                                                 \
    

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

  259.   }                                                                 \
    

  260.   __INLINE SFR& apply ()                                            \
    

  261.   {                                                                 \
    

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

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

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

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

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

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

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

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

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

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

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

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

  274.     else                                                            \
    

  275.       ref = val;                                                    \
    

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

  277.     changed = 0;                                                    \
    

  278.     return *this;                                                   \
    

  279.   }                                                                 \
    

  280.   struct {                                                          \
    

  281.     type volatile& ref;                                             \
    

  282.     type val;                                                       \
    

  283.     type changed;                                                   \
    

  284.     type zero_mask;                                                 \
    

  285.   };
    


  286. 

  287. #endif  // __LESTL_SFR_HPP

回复

收藏 举报

wkei007 发表于 2013-9-7 11:04 | 显示全部楼层
那家伙，居然说代码是老师复制贴粘过来的，真是无语了，是他以自个的水平去揣摩别人的水平，这也太自以为是了，真是井底之蛙，Lee老师别跟他这种人计较！
回复

收藏 举报

icecut 发表于 2013-9-7 15:41 | 显示全部楼层
如果c++变成这个样子,我想c++ primer之类的书就可以点火烧了....
回复

收藏 举报

icecut 发表于 2013-9-7 16:11 | 显示全部楼层
c++元编程真不是你这么玩的.....

送你四个字:邯郸学步
回复

收藏 举报

kseeker 发表于 2013-9-7 16:43 | 显示全部楼层
icecut 发表于 2013-9-7 16:11
c++元编程真不是你这么玩的.....

送你四个字:邯郸学步

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

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

收藏 举报

kseeker 发表于 2013-9-7 17:26 | 显示全部楼层
haiyuan254 发表于 2013-8-29 18:39
给你10000行这种代码让你维护，你试试~~~？？就这程序10000行中出1个Bug看能不能弄死维护的人，维护的人 ...

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

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

收藏 举报

john_lee 发表于 2013-9-7 17:36 | 显示全部楼层
icecut 发表于 2013-9-7 16:11
c++元编程真不是你这么玩的.....

送你四个字:邯郸学步

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

收藏 举报

icecut 发表于 2013-9-7 20:51 | 显示全部楼层
本帖最后由 icecut 于 2013-9-7 21:03 编辑
kseeker 发表于 2013-9-7 16:43
这东西诞生之初很多人，甚至包括Bjarne Strou-strup，都认为是“过于聪明”的东西。结果经过多年的演变， ...

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

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

收藏 举报

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

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

收藏 举报

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

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

收藏 举报

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

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

收藏 举报

下一页 »
1234下一页
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

快速回复 在线客服 返回列表 返回顶部