小编nha*_*123的帖子

如何启动trait定义的构造函数和析构函数以及类的构造函数和析构函数.例如,

trait Audit
{
    public function __construct()
    {
        parent::__construct(); // Doesn't work...

        $this->_name = __CLASS__;

        $this->AuditAction('Started');
    }

    public function __destruct()
    {
        parent::__destruct(); // Doesn't work...

        $this->AuditAction('Ended');

        echo $this->_log;        
    }

    public function AuditAction($n)
    {
        $this->_log .= $this->GetCurrentTimeStamp() . ' ' . $this->_name . ": $n" . PHP_EOL;
    }

    private function GetCurrentTimeStamp()
    {
        return (new DateTime())->format('[Y-m-d H:i:s]');
    }

    private $_name, $_log = '';
}

class C
{
    use Audit;

    public function __construct()
    {

    } …

在Windows平台上,我试图从我的变量所在的应用程序中转储内存.这是功能:

void MyDump(const void *m, unsigned int n)
{
        const unsigned char *p = reinterpret_cast<const unsigned char *>(m);
        char buffer[16];
        unsigned int mod = 0;

        for (unsigned int i = 0; i < n; ++i, ++mod) {
                if (mod % 16 == 0) {
                        mod = 0;

                        std::cout << " | ";

                        for (unsigned short j = 0; j < 16; ++j) {
                                switch (buffer[j]) {
                                        case 0xa:
                                        case 0xb:
                                        case 0xd:
                                        case 0xe:
                                        case 0xf:
                                                std::cout << " …

有没有办法找出接口的属性是否定义为只读？说，

interface ITest {
    readonly foo: number;
}

现在，TypeScript是否有某种反思或欺骗手段来获取此信息？例如：

let info = Reflect.get(ITest, 'foo');

if (info.isReadOnly()) { ... }

如何在8x8区域中移动列？例如,我有一个64位无符号整数,如下所示:

#include <boost/cstdint.hpp>

int main()
{
    /** In binary:
      * 
      * 10000000
      * 10000000
      * 10000000
      * 10000000
      * 00000010
      * 00000010
      * 00000010
      * 00000010
      */
    boost::uint64_t b = 0x8080808002020202;
}

现在,我想将第一个垂直行转换为四次,之后它变为:

/** In binary:
  * 
  * 00000000
  * 00000000
  * 00000000
  * 00000000
  * 10000010
  * 10000010
  * 10000010
  * 10000010
  */

  b == 0x82828282;

这只能通过逐位运算符相对快速地完成,还是什么？

我试图了解流行的r.js的好处.

好像......

• 连接手动选择的 JavaScript文件列表
• uglify /最小化组合代码
• 为CSS文件做一些类似的事情(合并它们)

此外,(它与通用联合/缩小工具的不同之处)似乎......

• 将节点式require()模块转换为AMD样式模块
• 命名匿名模块(例如define(['dependency'], function(){...})
• 为加载器插件提供一些支持,例如内联CSS文件

它好像不 ......

• 分析并自动解决文件中的依赖关系(例如,将文件包含foo.js到包中只是因为r.js找到了define(["foo"], ...)

这是正确的,还是我错过了什么？

有没有办法使用STL在容器内找到最大的容器？ATM,我有这种相当天真的方式:

int main()
{
        std::vector<std::vector<int> > v;

        ...

        unsigned int h = 0;

        for (std::vector<std::vector<int> >::iterator i = v.begin(); i != v.end(); ++i) {
                if (*i.size() > h) {
                        h = *i.size();
                }
        }
}

我有自己的DLL被注入另一个进程.从另一个进程,DLL通过boost :: message_queue将IPC消息发送到我的应用程序.我正在使用std :: stringstream来构造消息,如下所示:

class Client
{
    ...

    private:
        template <class T> void AddMessageParameter(const T &m)
        {
            _message &lt&lt m &lt&lt "|";
        }

        void SendMessage()
        {
            if (_mq && _message.str().length() < 1024) {
                // Do not send the same message again.

                if (_mq_last_sent_message != _message.str()) {
                    _mq_last_sent_message = _message.str();

                    try {
                        unsigned int tries = 0;

                        // Try send the message five times before giving up.

                        do {
                            if (_mq->try_send(_mq_last_sent_message.c_str(), _mq_last_sent_message.length(), 0))
                                tries = 5;
                            else
                                ::Sleep(128); …

我一直想知道,如果两次定义琐碎方法是好的还是坏的做法,这取决于
项目是在debug/release -state上.这是为了内联它们.例如,Foo.h:

class Foo
{
        public:
                ...

                const bool& IsBoolean() const;

        private:
                bool _boolean;
};

#ifndef _DEBUG

/** We're in release, so let's advice compiler to inline this...
  *
  *
  */

inline const bool& Foo::IsBoolean() const
{
        return _boolean;
}

#endif

现在,在Foo.cpp中:

#include "Foo.h"

...

#ifdef _DEBUG

/** We're debugging this, no need for inlining...
  *
  *
  */

const bool& Foo::IsBoolean() const
{
        return _boolean;
}

#endif

这完全没用吗？例如,由于编译器(MSVC)能够自行内联/优化方法？

然而,这是我多年来一直使用的东西.请纠正我,如果我在这里完全错了......

我需要捕捉

\d+\.\d+

要么

\d+

但没有别的。

例如，“ 0.02”，“ 1”和“ 0.50”应为正数匹配。我注意到我不能简单地使用类似

[\d+\.\d+|\d+]