相关疑难解决方法(0)

我正在开发一个库,并希望为我的用户提供一个公共接口,与隐藏在命名空间中的实际实现分开.这样,我只能更改HiddenQueue类而不更改仅向用户公开的myQueue.

如果我将HiddenQueue的C++代码放在myQueue.cpp文件中,编译器会抱怨说_innerQueue的类型不完整.我认为链接器能够解决这个问题.我在这做错了什么？

// myQueue.h
namespace inner{
    class HiddenQueue;
};

class myQueue{

public:
    myQueue();
);

private:

    inner::HiddenQueue _innerQueue;

};

///////////////////////////

// myQueue.cpp
namespace inner{
    class HiddenQueue{};
};

我是Qt的新手,我正在用简单的例子做一些练习.

我只是想用一个简单的应用程序来测试我的知识,通过编码,用户在QLineEdit小部件中键入文本,文本将显示在QLabel中.没有必要使它有用.我只是想试试.

在编译应用程序时,我没有错误.但是,打开窗口时,QLabel和QLineEdit窗口小部件不可见.

我的代码在这里:

在window.h

#ifndef WINDOW_H
#define WINDOW_H

#include <QMainWindow>

class QGridLayout;
class QLabel;
class QLineEdit;

class Window : public QMainWindow
{
    Q_OBJECT

public:
    explicit Window(QWidget *parent = 0);

private:
    QGridLayout *mainLayout;
    QLabel *label;
    QLineEdit *lineEdit;
};

#endif // WINDOW_H

Window.cpp

#include "Window.h"
#include <QGridLayout>
#include <QLineEdit>
#include <QLabel>

Window::Window(QWidget *parent)
    : QMainWindow(parent)
{
    mainLayout = new QGridLayout;
    label = new QLabel(tr("Text"));
    lineEdit = new QLineEdit;

    mainLayout->addWidget(label, 0, 0);
    mainLayout->addWidget(lineEdit, 1, 0);
    setLayout(mainLayout);

    connect(lineEdit, SIGNAL(textChanged(QString)),
            label, SLOT(setText(QString)));
}

main.cpp中 …

与特定任务相关的类依赖于某个第三方库来执行此任务（比如 JSON 序列化）。该库的使用对于客户端应该是透明的，并且该类的公共接口中不会引用任何第三方代码类或数据类型。

在引入私有方法之前，我只需将所需的#includes 添加到 .cpp 文件即可。但是，现在我根据第 3 方代码声明了一个私有方法，我必须将一些 #include 拉到头文件中，这反过来又导致在所有其他文件（包括我的类的头文件）中包含相应的头。

我正在考虑使用函数而不是私有方法，这样我就不必在标头中声明函数。当然，我必须将对我正在使用的字段的引用传递给这些函数。这是解决此问题的合理方法吗？或者是否有在使用私有方法时实现这种封装的最佳实践？

我在文件中有一个类,AType.h它在AType.cpp中实现.

# include "PrivateType.h"

class AType{
    private:
    int a, b, c;
    PrivateType varX;

    public:
    ...
};

我想在文件中使用类AType main.cpp,我需要包含AType.h,但我想避免包含PrivateType.h在main.cpp中.
我无法varX用malloc/new 创建.
main.cpp必须在编译时知道AType的大小.

目前的解决方案:(这很糟糕)

1 - 创建要打印的程序sizeof(AType).
2 - 更改标题:

# ifdef ATYPE_CPP
    # include "PrivateType.h"
#endif

class AType{
    private:
    # ifdef ATYPE_CPP
        int a, b, c;
        PrivateType varX;
    # else
        char data[ the size that was printed ];
    # endif

    public:
    ...
};

3 - 而AType.cpp将从以下开始:

# define ATYPE_CPP …

操作系统:xp
IDE:VS 2008
在我正在使用Visual C++进行的项目中,我已经声明了一个std::vector内部托管类

std::vector<pts> dataPoints;//this gives error c4368 : mixed type not allowed 

但这很有效

std::vector<pts> * dataPoints;//a pointer to the vector  

然后我在免费商店中创建了这个向量,就像在托管类的构造函数中一样

dataPoints = new std::vector<pts>(noOfElements,pts());//which is not so attractive.

我需要矢量的原因是因为有文件我正在阅读ifstream并将这些值存储在矢量中.
Q1)为什么我能够声明指向本机类型的对象(我猜)而不是对象？此外,在尝试向量之前,我尝试了托管数组

cli::array<Point> dataPoints //and i defined it later.

但是当我这样做的时候

ifile >> dataPoints[i].X;   

它给出了一个错误c2678:operator =没有超载int!!
Q2)为什么我不能在这里使用托管代码.起初我认为它可能是一个包装类Int,但随后autounboxing(转换运算符)应该处理它？还是Point :: X是合格的property,因此不被认为是正常的int？我错过了什么？这就是我选择vector和pts 解决的原因.
pts如下

 struct pts
{
  int X, int Y;
  pts() : X(0),Y(0){}
  pts(int x,int y) : …

在C++中,如果我们在某个基类中有一些虚函数(比如Base),我们想要覆盖这个虚函数,我们将不得不再次声明这个虚函数,使其在我们的派生类中编译.

class Base {
public:
    virtual void virtualFunction();
    static int s_whatSoEver[];
private:
    void _privateFunction();
}
class Derived {
public:
    virtual void virtualFunction();
}

这不是愚蠢的,因为如果我们想改变虚函数原型,我们必须改变derived-s的每个声明吗？

此外,为什么有必要在头文件中声明一些受保护或私有函数,因为头文件用于公共接口定义,而使用此接口的用户根本不需要关心它们？也许我们可以像Objective-C一样直接在.cpp文件中实现和声明私有或受保护的函数.

C++也没有静态初始化器,如果我们想要初始化一些静态类变量,我们必须为此创建一个类:

class BaseStaticVariableInitializer {
public:
    BaseStaticVariableInitializer() {
        Base::s_whatSoEver = new int[20];
        for (int i = 0; i < 20; i++) {
            s_whatSoEver[i] = xxx;
        }
    }
    ~BaseStaticVariableInitializer() {
         delete [] Base::s_whatSoEver;
    }
}

并特别为它初始化一个静态类常量:

static BaseStaticVariableInitializer s_baseStaticVariableInitializer;

对不起我的无知,但是你正确的方法来编写你的c ++代码以适应DRY？

首先要做的事情是:我知道我的问题很可能是基于一般的误解,但我希望我能向你表明我的观点.

我知道在将代码放入C++中的不同文件时,我们确实创建了一个.h(用于定义)和一个.cpp(用于实现).例如,在编写类库时,我必须在头文件中放置私有和公共成员的definitioj.但是,如果 - 出于某种原因 - 我想隐藏用户的私人信息该怎么办？

谢谢!

我想问一下C++中哪里是实例化实例变量的正确位置？我认为它不应该在类声明中,但除了面向对象设计不佳之外,我不会看到任何缺点:

class A{ member m; };

我认为最好是这样的:

class A{ extern member m; };

但我不知道如何在没有像这样的指针的情况下实现它:

class A{ member* m };

A::A(){ m = new member; }

是否有"干净的解决方案"在堆栈上实现这一点(不使用指针)？

也许我对这个问题很陌生，但是是否可以通过构造函数定义成员函数？

就我而言，我正在尝试编写一个类来执行稳健的模型拟合（使用RANSAC）。我希望这可以推广到不同类型的模型。例如，我可以使用它来确定一个平面到一组 3D 点的估计。或者，也许我可以确定两组点之间的转换。在这两个示例中，可能需要不同的误差函数和不同的拟合函数。静态函数调用可能看起来像，而不是使用类

model = estimate(data, &fittingFunc, &errorFunc);

我想知道我是否可以为这些模块化功能提供成员实例？

就像是

class Estimator
{
    private:
        // estimation params

        double errorFunc(std::vector<dtype>, double threshold); // Leave this unimplemented
        double fittingFunc(std::vector<dtype>, Parameters p); // Leave this unimplemented

    public:
        Estimator(void (*fittingFunc(std::vector<dtype>, Parameters), void (*errorFunc(std::vector<dtype>, double));

        dtype estimate(data); // Estimates model of type dtype. Gets implemented

};

Estimator::Estimator(void (*fittingFunc(std::vector<dtype>, Parameters), void (*errorFunc(std::vector<dtype>, double))
{
    fittingFunc = fittingFunc;
    errorFunc = errorFunc;
}

我想我已经在我的例子中混杂了正确的语法，但我希望这个问题很清楚。基本上我在问：构造函数能否接受函数指针作为参数并将它们分配为成员函数的实现？

其次，即使这是可能的，它是否被认为是不良形式？

更新：如果有帮助，这里是用于稳健估计的 MATLAB 代码，它具有我希望在 C++ 中复制的这种可推广结构

如果对用户隐藏此类的实现,是否可以在类中添加新函数.但是如果它需要为这个类添加一个新函数.

在我的 C++ 代码中，我定义了一些公共和私有标头。私有标头只能包含在基于某些 #ifdef 的公共标头中。

如果用户直接包含这些私有标头，如何向用户抛出错误或警告？