CAST(swap_info::json->>'医疗费总额' AS double precision)::int保留两位小数

这是一个PostgreSQL查询语句的一部分，用于从名为`swap_info`的列的JSON数据中提取出键为"医疗费总额"的值，并将其转换为双精度浮点数（double precision），然后进一步转换为整型，同时保留两位小数。

具体步骤解释如下：

1. `CAST(swap_info::json->>'医疗费总额' AS double precision)`：首先将`swap_info`列解析为JSON对象，然后通过`->>`操作符获取"医疗费总额"字段的值，这个过程会得到一个字符串。接着使用`CAST`函数将该字符串转换成`double precision`类型的数值。

2. `AS int`：表示后续将这个浮点数转换为整数类型（int）。

3. `::int保留两位小数`：实际上这里可能会有误解，因为`INT`类型通常不会保留小数部分。如果需要保留两位小数再转换为整数，应该先用`ROUND`或`FORMAT`函数精确到小数点后两位，然后再进行转换。不过在这个语法中，`double precision`已经可以存储最多8位小数，所以直接`AS int`会自动截断多余的小数部分。

正确的做法可能是先格式化，例如：

ROUND(CAST(swap_info::json->>'医疗费总额' AS double precision) * 100, 2)::int / 100

这会先四舍五入到两位小数，然后转换为整数。

相关问题

怎么将osgViewer::Viewer嵌入ui->openGLWidget

将 `osgViewer::Viewer` 嵌入到 `QOpenGLWidget` 中，可以通过以下步骤实现：

1. 继承 `QOpenGLWidget` 类，并实现以下虚函数：

class OsgWidget : public QOpenGLWidget, protected QOpenGLFunctions
{
public:
    OsgWidget(QWidget* parent = nullptr);
    virtual ~OsgWidget();

protected:
    void initializeGL() override;
    void resizeGL(int w, int h) override;
    void paintGL() override;
    void paintEvent(QPaintEvent* event) override;
    void keyPressEvent(QKeyEvent* event) override;
    void keyReleaseEvent(QKeyEvent* event) override;
    void mousePressEvent(QMouseEvent* event) override;
    void mouseReleaseEvent(QMouseEvent* event) override;
    void mouseMoveEvent(QMouseEvent* event) override;
    bool event(QEvent* event) override;
};

其中，`initializeGL`、`resizeGL` 和 `paintGL` 函数用于初始化 OpenGL 上下文并绘制场景，`paintEvent` 函数用于处理重绘事件，`keyPressEvent`、`keyReleaseEvent`、`mousePressEvent`、`mouseReleaseEvent` 和 `mouseMoveEvent` 函数用于处理键盘和鼠标事件，`event` 函数用于处理其他事件。

2. 在 `initializeGL` 函数中创建 `osgViewer::GraphicsWindow` 对象，并将其关联到 `osgViewer::Viewer` 对象中：

void OsgWidget::initializeGL()
{
    // Create an OSG graphics context
    osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits;
    traits->windowName = "OSG Widget";
    traits->x = 0;
    traits->y = 0;
    traits->width = width();
    traits->height = height();
    traits->doubleBuffer = true;
    traits->windowDecoration = false;
    traits->sharedContext = 0;

    // Create an OSG graphics window
    osg::ref_ptr<osgViewer::GraphicsWindow> gw = osg::GraphicsContext::createGraphicsWindow(traits.get());

    // Create an OSG viewer
    osg::ref_ptr<osgViewer::Viewer> viewer = new osgViewer::Viewer;
    viewer->getCamera()->setGraphicsContext(gw);
    viewer->getCamera()->setViewport(new osg::Viewport(0, 0, traits->width, traits->height));

    // Set the viewer's scene data
    osg::ref_ptr<osg::Node> scene = createSceneGraph();
    viewer->setSceneData(scene.get());

    // Save the viewer pointer for later use
    m_viewer = viewer;
}

其中，`createSceneGraph` 函数用于创建 OSG 场景图。

3. 在 `paintGL` 函数中将 `osgViewer::Viewer` 的帧缓冲区绑定到 `QOpenGLWidget` 的帧缓冲区，并使用 `osgViewer::Viewer::frame` 函数绘制一帧：

void OsgWidget::paintGL()
{
    // Bind OSG's frame buffer object to the OpenGL context
    m_viewer->getCamera()->getGraphicsContext()->realizeOpenGLContext();
    m_viewer->getCamera()->getGraphicsContext()->makeCurrent();
    m_viewer->getCamera()->getGraphicsContext()->bindPBufferToTexture();

    // Draw a frame
    m_viewer->frame();

    // Swap the buffers
    m_viewer->getCamera()->getGraphicsContext()->swapBuffers();
}

4. 在 `resizeGL` 函数中更新 `osgViewer::Viewer` 的视口：

void OsgWidget::resizeGL(int w, int h)
{
    // Update OSG's viewport
    m_viewer->getCamera()->setViewport(new osg::Viewport(0, 0, w, h));
}

5. 在 `paintEvent` 函数中强制刷新 `QOpenGLWidget`：

void OsgWidget::paintEvent(QPaintEvent* event)
{
    // Force redraw
    update();
}

6. 将 `OsgWidget` 添加到 `QMainWindow` 中：

int main(int argc, char** argv)
{
    QApplication app(argc, argv);
    QMainWindow mainWindow;

    // Create an OSG widget
    OsgWidget* osgWidget = new OsgWidget(&mainWindow);

    // Add the OSG widget to the main window
    mainWindow.setCentralWidget(osgWidget);

    mainWindow.show();

    return app.exec();
}

通过以上步骤，就可以将 `osgViewer::Viewer` 嵌入到 `QOpenGLWidget` 中，并在 Qt 应用程序中显示 OSG 场景图了。

std::vector<std::vector<int>> 实现矩阵转置，快速的方法

在C++中，`std::vector<std::vector<int>>`用于表示二维动态数组或矩阵，要实现矩阵转置，一种快速的方法是通过迭代器或引用交换行和列。以下是一个简单的示例：

#include <iostream>
#include <vector>

void transposeMatrix(std::vector<std::vector<int>>& matrix) {
    int n = matrix.size();
    if (n == 0 || n != matrix[0].size()) {
        std::cout << "Invalid matrix for transposition." << std::endl;
        return;
    }

    // 创建一个新的矩阵用于存储转置后的结果
    std::vector<std::vector<int>> transposed(n, std::vector<int>(n));

    // 使用两层循环交换行和列元素
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            transposed[j][i] = matrix[i][j];
        }
    }

    // 更新原始矩阵为转置后的结果
    matrix.swap(transposed);
}

// 示例
int main() {
    std::vector<std::vector<int>> matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    transposeMatrix(matrix);

    // 打印转置后的矩阵
    for (const auto& row : matrix) {
        for (int elem : row) {
            std::cout << elem << " ";
        }
        std::cout << "\n";
    }

    return 0;
}

在这个例子中，我们首先检查输入矩阵是否有效，然后创建一个新的矩阵进行转置操作。最后，我们将转置后的矩阵赋值给原矩阵，实现了原地转置。