不可能的快速委托是 std::function 的合适替代品吗？

如何解决不可能的快速委托是 std::function 的合适替代品吗？

我最近看到一篇名为“不可能的快速 c++ 委托”的文章和它的 c++11 版本，称为“修复的不可能的快速 c++ 委托”，这似乎很受欢迎。似乎它们具有与 std::function 相同的用例，即将不同的函子类型强制转换为单一类型。但是，作者声称它们的性能要高得多。

它们是 std::function 的合适的、高性能的替代品吗？如果是这样，为什么 std::function 没有以相同的方式实现？或者难以置信的快速 C++ 委托有什么缺点吗？

编辑：正如评论所要求的那样，“不可能的快速 c++ 委托”的主要思想似乎是将指向无类型数据的指针与函数指针一起存储，该函数指针将指向无类型数据的指针作为参数。 “修复了不可能的快速 c++ 委托”扩展了以前的功能以支持 lambdas 等。这是“不可能的快速 C++ 委托”中显示的代码摘要

onPrepare: function() {
        return global.browser.getProcessedConfig().then(function(config) {
            var jasmineReporters = require('jasmine-reporters'),fs = require('fs-extra');
 
            fs.emptyDir('./reports/screenshots/',function(err) {
                if (err) {
                    console.log(err);
                }
            });
 
            jasmine.getEnv().addReporter(new jasmineReporters.JUnitXmlReporter({
                consolidateall: true,savePath: './reports/',filePrefix: 'xmloutput'
            }));
 
            jasmine.getEnv().addReporter({specstarted: function(result) {
                console.log('\n' + result.description);
            }});
 
            jasmine.getEnv().addReporter({
                specDone: function(result) {
                    browser.getCapabilities().then(function(caps) {
                        var browserName = caps.get('browserName'),onFailure = caps.get('screenshotsOnlyOnFailure');
                        if ((result.status == 'Failed' && onFailure) || !onFailure) {
                            browser.takeScreenshot().then(function(png) {
                                var stream =
                                fs.createWriteStream('./reports/screenshots/' + browserName+'-' +result.fullName+ '.png');
                                stream.write(new Buffer(png,'base64'));
                                stream.end();
                            });
                        }
                    });
                }
            });
        });
    },onComplete: function() {
        var browserName;
        var browserVersion;
        var content;
        var capsPromise = browser.getCapabilities(),fs = require('fs-extra');
 
        capsPromise.then(function(caps) {
            browserName = caps.get('browserName');
            browserVersion = caps.get('version');
 
            var HTMLReport = require('protractor-html-reporter'),testConfig = {
                    reportTitle: 'Report Title',outputPath: './reports/',screenshotPath: './screenshots/',testbrowser: browserName,browserVersion: browserVersion,modifiedSuiteName: false,screenshotsOnlyOnFailure: false
                };
            new HTMLReport().from('./reports/xmloutput.xml',testConfig);
            content = fs.readFileSync('./reports/chrome-test-report.html','utf8');
            fs.writeFileSync('./reports/index.html',content,'utf8');
        });
    }

这里是两篇文章的链接： https://www.codeproject.com/Articles/11015/The-Impossibly-Fast-C-Delegates

https://www.codeproject.com/Articles/1170503/The-Impossibly-Fast-Cplusplus-Delegates-Fixed

解决方法

难以置信的快速 C++ 委托有什么缺点吗？

仅提供示例句柄：

固定签名void(int)（可以通过模板轻松修复）
方法指针（及其类）（因此没有直接使用 lambda/functor，也没有常规函数指针）。

lambda/Functor 可以很容易地适应它们的 operator()。不确定处理函数指针的可能开销。

提供的示例无法处理：

所有权。

这是两种实现之间的主要区别，并且增加了开销（与无所有权相比，在创建和执行时）

注意：还有其他"function_view"

它们是 std::function 的合适的、高性能的替代品吗？

如果您不需要所有权，可以。

如果是这样，为什么 std::function 的实现方式不同？

因为 std::function 应该处理所有权。