小编Gra*_*pes的帖子

我们以下面的方法为例:

void Asset::Load( const std::string& path )
{
    // complicated method....
}

这种方法的一般用途如下:

Asset exampleAsset;
exampleAsset.Load("image0.png");

由于我们大多数时候都知道Path是一个临时右值,所以添加这个方法的Rvalue版本是否有意义？如果是这样,这是一个正确的实施;

void Asset::Load( const std::string& path )
{
    // complicated method....
}
void Asset::Load( std::string&& path )
{
     Load(path); // call the above method
}

这是编写rvalue版本方法的正确方法吗？

我想知道这是否是一种可接受的写回调的方法:

存储回调:

struct EventHolder {
    std::function<void()> Callback;
    EventTypes::EventType Type;
};
std::vector<Events::EventHolder> EventCallbacks;

方法定义:

void On(EventType OnEventType,std::function<void()>&& Callback)
{
    Events::EventHolder NewEvent;
    NewEvent.Callback=std::move(Callback);
    NewEvent.Type=OnEventType;
    EventCallbacks.push_back(std::move(NewEvent));
}

绑定事件:

Button->On(EventType::Click,[]{
    // ... callback body
});

我最大的问题是关于通过值传递回调.这是一种有效的方法吗？

我们假设我们有一个非常基本的class A:

class A {
    public:
        void SetName(const std::string& newName) {
            m_name=newName;
        }

        void Print() const {
            std::printf("A::Print(). Name: %s\n",m_name.c_str());
        }
    private:
        std::string m_name;  
};

我们希望与扩展此类,class B所以我们增加我们的虚拟析构函数,改变一个成员virtual,改变private到protected对INH:

class A {
    public:
        virtual ~A() {}

        void SetName(const std::string& newName) {
            m_name=newName;
        }

        virtual void Print() const {
            std::printf("A::Print(). Name: %s\n",m_name.c_str());
        }
    protected:
        std::string m_name;

};

class B : public A {
    public:
        virtual void Print() const {
            std::printf("B::Print(). Name: %s\n",m_name.c_str());
        } …

假设我有两个类:

class A
{
    public:
    A* Hello()
    {
        return this;
    }
}

class B:public class A
{
    public:
    B* World()
    {
        return this;
    }
}

让我们说我有一个B像这样的类的实例:

B test;

如果我打电话test.World()->Hello()说那会很好.但是test.Hello()->World()因为Hello()返回A类型不起作用.

我Hello()该如何归还B？我不想使用virtual函数,因为我们有超过20个不同的类继承A.

我来自C++世界所以我非常习惯锁定线程和互斥锁防护.假设这个基本功能:

async Task BasicProcess() {
    // await time consuming task
}

如何锁定此功能,以便一次BasicProcess只能运行一个？

这就是我想要实现的目标:

async Task BasicProcess() {
    lock (BasicProcessLock) {
         // await time consuming task
    }
}

此代码在IE11中生成无效响应:

<form onsubmit="alert('Valid Number!');return false;">
<input type="number" step="0.01" value="9583.89" min="0" max="10000" />
<input type="submit" />
</form>

和一个JSFiddle:https://jsfiddle.net/pvsojuhs/

预期输出为"有效数字!" 但似乎IE11认为这是一个无效的数字.

这个问题有解决办法吗？其他数字,如"9583.19"工作正常.

其他一些测试:

• 8192.12(无效)
• 8192.13(无效)
• 8192.14(无效)
• 8192.15(有效)
• 8192.20(有效)
• 8192.21(无效)

请考虑以下示例:

function Process()
    local Container=NewContainer()
    Container:On(EventType.Add,function()
        Container:DoSomething()
    end)
    -- Does not Garbage Collect
end

在luabridge,我保存function()为LuaRef延伸寿命的Container,它不会是GCed因为它是一个RefCountedObjectPtr

这是一个解决方法,我用来使用一个有效的弱表,但它看起来很难看:

function Process()
    local Container=NewContainer()
    local ParamsTable={ Container=Container }
    setmetatable(ParamsTable, { __mode = 'k' })

    Container:On(EventType.Add,function()
        ParamsTable.Container:DoSomething()
    end)
    -- Garbage Collects fine
end

有没有办法让LuaRef这个功能与此类似？或许还有另一种解决方法？

假设我们有一个传递给函数的表,它现在位于堆栈顶部,如下所示:

// -1 = table

是否可以从堆栈中的表中获取元表？我可以简单地使用已知名称标识符来获取它,如下所示:

luaL_getmetatable(L, "Foo");

但我想重新使用该函数并从堆栈中的表中获取元表.

可能有一种简单的方法可以做到这一点,但我似乎找不到这个功能.

我们已成功将 Y​​odlee IAV API 连接到我们的银行帐户，并注意到无法识别银行路由信息。

我们需要这些号码来将资金转移给用户。您可以查看：https://developer.yodlee.com/Instant_Account_Verification (IAV)_API/IAV_Services_Guide/API_References/IAV_REST_API_Reference/getItemVerificationData

您确实获得了一个帐号，但没有与该帐户关联的分行/交通号码。我已经与支持人员交谈过，他们说他们不会从加拿大银行窃取这些信息。

有没有其他方法可以获取此信息？

以下是从 Yodlee IAV 检索到的信息：

[{
       "itemVerificationInfo": {
              "transactionId": "XXXXXXXXXX",
              "itemId": 1000003,
              "contentServiceId": 3736,
              "requestStatus": { "verificationRequestStatus": "SUCCEEDED" },
              "requestType": { "name": "IAV_FAST" },
              "requestTime": "2015-05-26T21:07:34-0700",
              "completionTime": "2015-05-26T21:08:03-0700",
              "completed": true,
              "statusCode": 0,
              "localeErrorMessage": "LOCALE_NOT_SUPPORTED",
              "requestedLocale": "en_US",
              "derivedLocale": "en_CA",
              "siteRefreshStatus": {
                      "siteRefreshStatusId": 5,
                      "siteRefreshStatus": "REFRESH_COMPLETED"
              }
       },
       "accountVerificationData": [{
              "accountType": { "name": "CHECKING" },
              "availableBalance": {
                      "amount": "9.99", 
                      "currencyCode": "CAD"
              },
              "itemVerificationInfo": {
                      "transactionId": "XXXXXXXXXX",
                      "itemId": 1000003,
                      "contentServiceId": 3736,
                      "requestStatus": …

假设以下lua代码:

local FooTable={ ["FooKey"]="FooValue" }

索引"FooValue"是"FooKey".所以我可以像这样访问它而没有任何问题(假设FooTable位于堆栈顶部.):

lua_getfield(L, -1, "FooKey");

当我尝试这样的事情时:

local FooTable={ "FooValue" }

我会假设索引"FooValue"是"1".但以下给了我一个nil回报.

lua_getfield(L, -1, "1");

是否有一种特殊的方法来访问表中的数字键？