使用c++编写qt时，如何将vector<string>强转为void*传递地址，再强转为vector<string>使用

将 `vector<string>` 强制转换为 `void*` 是不安全的，因为 `vector<string>` 是一个类，它有很多成员变量和成员函数，强制转换后会丢失这些信息，导致程序出错。正确的做法是使用 `reinterpret_cast` 将 `vector<string>` 的地址转换为 `void*`，再在需要使用的地方将 `void*` 转换回 `vector<string>`。

示例代码如下：

// 将 vector<string> 转换为 void*
vector<string> strVec;
void* pData = reinterpret_cast<void*>(&strVec);

// 在需要使用的地方将 void* 转换回 vector<string>
void* pTemp = getData(); // 假设 getData() 返回 void*
vector<string> tempVec = *reinterpret_cast<vector<string>*>(pTemp);

需要注意的是，这种类型的转换是危险的，如果你不确定自己在做什么，就应该避免这种转换。

相关问题

qt父窗口mainwindow有两个容器vector<string> delete_pathlists; vector<unsigned char> crosstypelists; 在子窗口deletewindow上显示出来，给出C++完整示例

好的，以下是一个简单的示例：

MainWindow.h:

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <vector>
#include <string>

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = nullptr);
    ~MainWindow();

private slots:
    void on_deleteButton_clicked();

private:
    Ui::MainWindow *ui;
    std::vector<std::string> delete_pathlists;
    std::vector<unsigned char> crosstypelists;
};

#endif // MAINWINDOW_H

MainWindow.cpp:

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "deletewindow.h"

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    // 添加一些示例数据
    delete_pathlists.push_back("path1");
    delete_pathlists.push_back("path2");
    delete_pathlists.push_back("path3");

    crosstypelists.push_back(1);
    crosstypelists.push_back(2);
    crosstypelists.push_back(3);
}

MainWindow::~MainWindow()
{
    delete ui;
}

void MainWindow::on_deleteButton_clicked()
{
    // 创建删除窗口并传递数据
    DeleteWindow *deleteWindow = new DeleteWindow(this, delete_pathlists, crosstypelists);
    deleteWindow->show();
}

DeleteWindow.h:

#ifndef DELETEWINDOW_H
#define DELETEWINDOW_H

#include <QDialog>
#include <vector>
#include <string>

namespace Ui {
class DeleteWindow;
}

class DeleteWindow : public QDialog
{
    Q_OBJECT

public:
    explicit DeleteWindow(QWidget *parent = nullptr,
                          const std::vector<std::string>& delete_pathlists = std::vector<std::string>(),
                          const std::vector<unsigned char>& crosstypelists = std::vector<unsigned char>());
    ~DeleteWindow();

private:
    Ui::DeleteWindow *ui;
};

#endif // DELETEWINDOW_H

DeleteWindow.cpp:

#include "deletewindow.h"
#include "ui_deletewindow.h"

DeleteWindow::DeleteWindow(QWidget *parent,
                           const std::vector<std::string>& delete_pathlists,
                           const std::vector<unsigned char>& crosstypelists) :
    QDialog(parent),
    ui(new Ui::DeleteWindow)
{
    ui->setupUi(this);

    // 在窗口中显示数据
    for (const auto& path : delete_pathlists) {
        ui->pathList->addItem(QString::fromStdString(path));
    }

    for (const auto& type : crosstypelists) {
        ui->typeList->addItem(QString::number(type));
    }
}

DeleteWindow::~DeleteWindow()
{
    delete ui;
}

在这个示例中，我们在 `MainWindow` 中创建了一个 `vector<string>` 和一个 `vector<unsigned char>`，然后在点击删除按钮时打开了一个 `DeleteWindow` 窗口并将这些数据传递给它，在 `DeleteWindow` 中我们可以将这些数据显示在两个列表中。

C++ 如何使用 Boost 序列化和 QTsocket 来发送和接收 std::vector<cv::Vec6f> 对象：

你可以使用Boost序列化库和QTsocket库来发送和接收`std::vector<cv::Vec6f>`对象。下面是一个简单的示例代码：

#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/serialization/vector.hpp>
#include <QTcpSocket>
#include <QDataStream>

// 序列化函数
template<class Archive>
void serialize(Archive& ar, cv::Vec6f& vec, const unsigned int version)
{
    ar & vec[0];
    ar & vec[1];
    ar & vec[2];
    ar & vec[3];
    ar & vec[4];
    ar & vec[5];
}

int main()
{
    std::vector<cv::Vec6f> dataToSend;
    // 填充数据到dataToSend

    // 创建QTcpSocket对象
    QTcpSocket socket;

    // 连接到服务器
    socket.connectToHost("server_address", port_number);

    if (socket.waitForConnected())
    {
        // 创建QDataStream对象来写入数据
        QDataStream stream(&socket);
        // 使用Boost序列化库将数据序列化为字符串
        std::stringstream ss;
        boost::archive::text_oarchive oa(ss);
        oa << dataToSend;
        std::string serializedData = ss.str();

        // 将序列化的数据发送到服务器
        stream << QString::fromStdString(serializedData);
    }

    // 接收数据
    if (socket.waitForReadyRead())
    {
        // 创建QDataStream对象来读取数据
        QDataStream stream(&socket);
        QString receivedData;
        // 从服务器接收数据
        stream >> receivedData;

        // 使用Boost序列化库将接收到的数据反序列化为std::vector<cv::Vec6f>对象
        std::string serializedData = receivedData.toStdString();
        std::stringstream ss(serializedData);
        boost::archive::text_iarchive ia(ss);
        std::vector<cv::Vec6f> receivedVector;
        ia >> receivedVector;

        // 使用接收到的数据进行处理
        // ...
    }

    // 关闭连接
    socket.disconnectFromHost();

    return 0;
}

请确保在编译时链接了Boost序列化库和QTsocket库，并根据实际情况替换`"server_address"`和`port_number`为服务器的地址和端口号。