标签: wrapper

我正在尝试转换现有的代码库以使用在lunar SDK 中的vulkan.hpp 中定义的包装器。

特别是，我有以下代码行：

vkEnumerateInstanceLayerProperties(&layerCount, nullptr);

这是使用 vulkan 进行操作的原生 C 方式。

我尝试将其更改为：

vk::enumerateInstanceLayerProperties(&layerCount, nullptr);\n这是 vulkan.hpp 的命名约定。然而，这无法编译，并出现多个错误，第一个是error: \xe2\x80\x98unsigned int*\xe2\x80\x99 is not a class, struct, or union type

vulkan.hpp中定义的签名是：

template <typename Allocator, typename Dispatch>\n  VULKAN_HPP_INLINE typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateInstanceLayerProperties(Allocator const& vectorAllocator, Dispatch const &d )\n

我的假设是第一个参数需要是一个向量：\nstd::vector<vk::LayerProperties> availableLayers;\n vk::enumerateInstanceLayerProperties(availableLayers, nullptr);

然而，这也无法编译，警告我：\nerror: request for member \xe2\x80\x98vkEnumerateInstanceLayerProperties\xe2\x80\x99 in \xe2\x80\x98d\xe2\x80\x99, whichis of non-class type \xe2\x80\x98std::nullptr_t\xe2\x80\x99

d是函数的第二个参数。

成功编译这段代码需要什么调度？

我能够运行我的 C++ 代码来显示图像，但我正在尝试将其与其他一些 C 代码集成。

我正在寻找有关如何在 OpenCV 中为我的 C++ 代码编写 C 包装器的演练。将来我需要能够在我的 C 代码中调用这个 C++ 方法！

#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <iostream>

using namespace cv;
using namespace std;

int main( int argc, char** argv )
{
    if( argc != 2)
    {
     cout <<" Usage: display_image ImageToLoadAndDisplay" << endl;
     return -1;
    }

    Mat image;
    image = imread(argv[1], CV_LOAD_IMAGE_COLOR);   // Read the file

    if(! image.data )                              // Check for invalid input
    {
        cout <<  "Could not open or find the image" << …

我有一个字符串（jsonData）通过 Jackson 对象映射器映射到 json，如下所示到 JaxB。

var completeJson = objectMapper.readValue(jsonData, Data.class);
myDto.setFirstName(completeJson.getFirstName())
myDto.setLastName(completeJson.getLastName()))
.....
.....etc..etc

我能够很好地映射到上面的字符串。但是，我在映射到 jooq JSON 对象时遇到问题。我想我现在必须将 jsonData 转换为 jooq JSON。

我该怎么做？

JSON newJson = objectMapper.(best method to use);

myDto.setJsonSource(newJson)
    

或者也许我必须创建某种包装器？

jooq配置的DTO

public myDto setJsonSource(JSON jsonSource) {
    this.jsonSource = jsonSource;
    return this;
}

我已经在堆栈溢出和谷歌上运行了几个小时了。我似乎无法理解如何在包装结构中存储函数指针及其参数。

下面的类包装了一个函数（在本例中是一个带有模板化返回类型和参数的打包任务）。下面列出了包装器的主要部分。

编辑：我不使用 std::function 的原因是因为包装器（ThreadTask）包装了一个 std::packaged_task ，该任务被移动到线程安全双端队列中。Packaged_task 是可移动构建的，并且不支持复制，而 std::function 则支持复制。因此我制作了一个定制包装。

编译器给出错误并指出该函数不接受 0 个参数。但我不知道如何传递参数/存储它们。

class ThreadTask {
    struct BaseInterface {

        virtual void Call() = 0;
        virtual ~BaseInterface() {};
    };
    std::unique_ptr<BaseInterface> mImplementation;

    template <typename F, typename...Args>
    struct BaseFunc : BaseInterface {
        F func;

        BaseFunc(F&& f, Args... args) : func(std::move(f)) {}
        void Call() { func(); }
    };
};

我尝试过以不同的方式解开这些论点，但我似乎无法使其发挥作用。我想我应该通过 std::forward 转发它们，但我不知道如何存储参数

我正在查看Wrapper类的.h文件.该类包含一个私有成员:

T* dataPtr;

(其中,T是如template < class T >在.h文件的顶部定义)

该类提供了两个"*重载运算符"方法:

T& operator*()
{
   return *dataPtr;
}

const T& operator*() const
{
  return *dataPtr;
}

两者都只是简单地返回*dataPtr,但*dataPtr实际上用简单的英语返回的符号是什么？它如何适合返回类型" T&"？

当我踏上Erlang美妙世界的旅程时,我注意到它的美丽,但更重要的是我注意到它的速度.这让我很奇怪,因为Erlang非常善于生成轻量级进程,所以将它用作其他进程的包装是否有意义.

作为一个例子,我使用rspec为ruby编写测试.假设我有10,000个测试,所有测试都可以独立运行而没有任何问题.是否有意义使用Erlang生成10,000个rspec并同时运行每个测试而不是rspec顺序运行每个测试？或者这只是一个完全荒谬的想法？

当运行以下程序并输入一个字母时,其中一个输出窗口显示该字母显然不是数字.为什么？

import javax.swing.JOptionPane;

/**
 * This program demonstrates some of the Character
 * class's character testing methods
 * 
 *
 */
public class CharacterTest {

public static void main(String[] args){
    String input;   //To hold the user's input
    char ch;    //To hold a single character

    //Get a character from the user and store
    //it in the ch variable
    input=JOptionPane.showInputDialog("Enter "+
            "any single character.");

    ch= input.charAt(0);

    //Test the character
    if(Character.isLetter(ch)){
        JOptionPane.showMessageDialog(null, "This is a letter.");
    }

    if(Character.isDigit(ch));{
        JOptionPane.showMessageDialog(null, "Thit is a digit.");
    } …

在我的Windows API包装器中,我可以选择在出现错误时出现一个消息框.我有一个我不能真正确定的.

这是我的主要功能:

int main()
{
    Window win; //create default window with default class (name changes each new instance)

    return messageLoop(); //the familiar GetMessage() while loop, returns msg.wParam
}

这一切都很好,但当我关闭我的窗口(刚通过X按钮测试)时,我得到以下消息(这是我复制消息框时得到的):

---------------------------
Error
---------------------------
File: "G:\programming\v2\wwbasewindow.h"
Function: _fakeWndProc
Line: 61
Error Code: 1410
Error: Class already exists.


---------------------------
OK   
---------------------------

现在很清楚这个错误来自哪里,但不完全是为什么.这是_fakeWndProc功能.调用该函数后的整个wrap (function, args)语法检查GetLastError().这就是您没有看到错误检查的原因.

LRESULT CALLBACK BaseWindow::_fakeWndProc (msgfillparams) //trick procedure (taken from someone's gui wrapper guide)
{
    BaseWindow * destinationWindowPtr = 0; //for which window message …

我是编程的新手.告诉我Integer x= 59;和Integer x= new Integer (59); 他们之间的区别 他们基本上做同样的事情,我得到输出任何一种方式.

public class WrapperClass
{
    public static void main(String args[]) 
    {
        Integer x= 59; // 
        byte y= x.byteValue();
        System.out.println(y);
    }
}

和

public class WrapperClass
{
    public static void main(String args[]) 
    {
        Integer x = new Integer (10);
        byte y= x.byteValue();
        System.out.println(y);
    }
}

继问题代理,装饰器,适配器和桥接模式有何不同？,您如何描述我需要多次实施的以下模式？

场景是我引用了来自第三方类的静态方法或变量,但我想将它隐藏在接口后面,以便我可以模拟它进行测试.

例如,在Java中,commons-lang库有一个SystemUtils类,常量为IS_OS_WINDOWS等.我想运行独立于底层操作系统的测试并模仿各种操作系统,所以我按如下方式包含对常量的访问:

interface ISystemUtils {
    boolean isOsWindows();
}

class SystemUtilsImpl implements ISystemUtils {
    @Override
    public boolean isOsWindows() {
        return SystemUtils.IS_OS_WINDOWS;
    }
}

这是一个代理,一个通用的"包装",还是其他什么？