小编Gui*_*cot的帖子

我有这个问题。它不断抛出错误：

use of class template 'std::unique_ptr' requires template arguments

我已经搜索了一个小时。我试过用c++17编译，还是不行。如何让 MariaDB 连接器正常工作？我安装了 MariaDB 连接器。我在 Debian 10 上。并使用 clang++ v7 进行编译。我尝试在标题中添加 <template> 选项，但仍然无效。

我正在使用这个编译： clang++ -I/usr/include/mariadb/concpp/compat -O3 -Wall -o ./getUsers ./getUsers.cpp -lmariadbcpp

#include <iostream> 
#include <cstring>
#include <mariadb/conncpp.hpp>

using namespace std;

// Main Process
int main(){
    try {
        // Instantiate Driver
        sql::Driver* driver = sql::mariadb::get_driver_instance();

        // Configure Connection
        sql::SQLString url("jdbc:mariadb://x.x.x.x:3306/todo");
        sql::Properties properties({{"user", "xxxx"}, {"password", "xxxx"}});

        // Establish Connection
        std::unique_ptr conn(driver->connect(url, properties));

        // Create a new Statement
        std::unique_ptr stmnt(conn->createStatement());
        // Execute query …

我有一个名为 的类型the_bad。the_good我想用模板元函数替换该类型。我预计该模板元函数会非常复杂，因此我们将其称为the_ugly.

我的问题是它the_bad可以嵌套在其他模板中，并且我想保持其他模板和参数不变。这是我的意思的一个例子，其中的实现不完整the_ugly：

struct the_good {};
struct the_bad {};

template<typename T>
struct the_ugly_impl {
    using type = T;
};

template<>
struct the_ugly_impl<the_bad> {
    using type = the_good;
};

template<typename T>
using the_ugly = typename the_ugly_impl<T>::type;

// passes, yay!
static_assert(std::same_as<the_good, the_ugly<the_bad>>);

// doesn't pass
static_assert(std::same_as<std::vector<the_good>, the_ugly<std::vector<the_bad>>>);

// doesn't pass
static_assert(std::same_as<std::list<std::vector<the_good>>, the_ugly<std::list<std::vector<the_bad>>>>);

我该如何修复，the_ugly以便它在任何嵌套级别替换the_bad为，同时保持所有其他模板和其他模板参数不变？the_good

我有一个最近解决的错误,但我想了解原因.我有一个使用c ++ 11的cmake项目.

这适用于mac osx但不适用于ubuntu.它在ubuntu上返回null.

obj *getPointer(){
  obj test = obj(1,2,3);
  return &test;
}

这适用于:

obj *getPointer(){
  obj* ptr;
  obj test = obj(1,2,3);
  ptr = &test
  return &ptr;
}

Class Example
{
    // ...
};

int main()
{
    Example** pointer = new Example*[9];

    for(int i = 0; i < 10; i++)
    {
        pointer[i] = new Example();
    }

    for(int i = 0; i < 10; i++)
    {
        delete pointer[i];
    }

    delete[] pointer; // <--- This is problem
    pointer = nullptr;
}

我试图将对象的地址保存在数组中。当我尝试删除它们时，for循环工作得很好，但delete[] pointer会导致“写到堆缓冲区的内存末端”错误。我究竟做错了什么？我也应该删除吗？

我听说在C ++中不建议使用指针，但我不明白为什么。

我的问题是我想创建一个类对象向量来管理我的类。

vector<MyClass> vectorOfClass;

自然地，为了获得更好的性能，我应该使用类对象指针的向量吗？

vector<MyClass *> vectorOfClass;

也许可以创建类对象的引用向量？

vector<MyClass &> vectorOfClass;

所以我的问题是：

• 这些方式有什么区别？
• 创建类对象向量的最优化方法是什么？

我试图实现 Prim 的算法（急切），它需要跟踪到顶点的最佳输入边（最低成本）。为此，我将 stl map 用作：

std::map<int, Edge*> bestEdgeFor;

但是，当我尝试为某个键分配边时，实际存储的是带有数据成员垃圾值的边。因此，我得到一些随机边缘作为输出。但是，当我使用相同的数据分配 Edge 类的新实例时，它可以正常工作。

bestEdgeFor[destNode] = &e; //Doesn't work
bestEdgeFor[destNode] = new Edge(e.from,e.to,e.cost); // Works

这是 Edge 类定义：

class Edge {
public:
    int from;
    int to;
    int cost;
};

我无法弄清楚到底是什么问题。是不是我们不能直接分配一个类的对象？请原谅我的天真。

这是Graph类，我在这个类的一个成员函数中进行赋值操作。e来自adjList. 范围有效吗？

class Graph {
    int V;
    std::map<int, std::list<Edge>> adjList;
    map<int, Edge*> bestEdgeFor;
public:
    void relaxEdgesAtNode(int currentNode, MinIndexedPQ&  ipq, int* visited){
        visited[currentNode] = 1;
        for(Edge e : adjList[currentNode]) {
            int destNode = e.to;

            if(visited[destNode]){
                continue;
            }

            if(!ipq.contains(destNode)) { …

addComponent我正在使用可变参数来尝试对我正在使用的类进行模板化，当我尝试在类中调用该函数时，出现该函数不接受 3 个参数的错误。我非常不确定为什么会这样，而且我还没有找到解决办法。

班级代码：

template <typename T, typename... Args>
class RenderComponentGroup : public RenderGroupBase
{
public:
using RenderGroupBase::RenderGroupBase;
void iterate() { IterateRenderComps<T>(m_Components); };
void addComponent(std::vector<RenderComponent*>* compPointers, Args... arguments)
{
    //Check if any dead
    for (int i = 0; i < m_Components.size(); i++)
    {
        if (m_Components[i].isDead())
        {
            m_Components.emplace(m_Components.begin() + i, arguments...);
            m_Components[i].updatePointer();
            return;
        }
    }

    //Resize components array
    m_Components.emplace_back(arguments...);
    m_Components[m_Components.size() - 1].attachToObject(compPointers);
    for (int i = 0; i < m_Components.size(); i++)
    {
        m_Components[i].updatePointer();
    }
}
private:
    unsigned int m_ID = …

我正在尝试创建一个构造函数来验证输入并在输入无效时引发异常。

假设我有一个构造函数，它仅接受 int a 的 mod 12 值、b 的 mod 16 值以及 c 的大于 0 的值。我正在尝试使用std::invalid_argument. 我将如何实现异常处理程序？这会抛出异常吗？如果输入的值超出范围？

Mod(int a, int b, int c) {
   try {
       if (a > 11 || a < 0 || b > 15 || b < 0 || c < 0) {
           throw std::invalid_argument("Invalid Argument");
       }
   } catch (std::invalid_argument const& value) {
       std::cerr << "Invalid Argument " << value.what() << '\n';
   }
}

我使用STB库将图像加载到内存中.特定函数stbi_load返回指向a的指针unsigned char,该指针是一个数组.

我很想将新的C++ 17 API用于原始数据,std::byte这将使我更具表现力,让我逐个像素地对原始数据进行别名,或者通过将其转换为不同的数据类型来逐个颜色(不同大小的整数).

现在我尝试了这个:

std::unique_ptr<std::byte[], stbi_deleter>(stbi_load(...));

当然,由于缺乏隐式转换,它不起作用.

然后我尝试了:

std::unique_ptr<std::byte[], stbi_deleter>(
  static_cast<std::byte*>(stbi_load(...))
);

同样,它仍然没有奏效.我不得不决定使用reinterpret_cast.并让我怀疑这种转换是否合法.我unsigned char*可以std::byte* 根据严格的别名规则合法地转换为？然后我可以将数据转换为另一种数据类型std::uint32_t*并进行变异吗？这会破坏别名规则吗？

在这些条件下,我编写了下一个Singleton类:
1 - 我想要一个且只有一个类的实例存在并且可以从整个游戏引擎访问.
2 - Singleton被密集使用(每帧数千次)所以我不想写一个额外的GetInstance()函数,我试图避免任何额外的函数调用性能
3 - 一种可能性是让GetInstance()像内联一样这个 :

inline Singleton* Singleton::GetInstance()
{
  static Singleton * singleton = new Singleton();
  return singleton;
}

但这会引起一个引用问题,每次调用时都会有一个对单例的新引用,用于修复用c ++编写的内容:

class Singleton{
private:
    static   Singleton* singleton;
    Singleton(){}

public:
    static inline  Singleton* GetInstance() // now can be inlined !
    {
        return singleton;
    }

    static void Init()
    {
        // ofc i have to check first if  this function
        // is active only once
        if(singleton != nullptr)
        {
            delete singleton;
        }

        singleton = new Singleton();
    } …