标签: forward-declaration

如何解决以下循环依赖？

typedef boost::variant<int, bool, double, std::string, Structure> Value;
typedef std::list<std::pair<std::string, ValueContainer>> Structure;
typedef std::vector<Value> ValueContainer;

我试图用更多C++形式表示来自C api数据库库的对象.此数据库允许存储值或值数组,以及具有Structures的表示,如下所示:

typedef struct ApiStructureMember 
{
    char* name;
    struct ApiValueContainer value;
    struct ApiStructureMember_T* next;
} ApiStructureMember_T;

最后,union用于表示值,如下所示:

typedef struct ApiValue 
{
    union 
    {
        int i;
        const char*   s;
        ...
        struct ApiStructureMember_T* firstStructureMember;
    } value;
} ApiValue_T; 

当我尝试这个例子时：

template <typename T>
concept only_int = std::same_as<T, int>;

int add_ints(only_int auto&&... args) {
    return (std::forward<decltype(args)>(args) + ... + 0);
}

它有效......但是当我只像这样声明它时：

template <typename T>
concept only_int;

...

// defined later on...

它会抛出编译错误。

这是缺少的功能吗？还是打算就这样离开？

Observation: the codes pasted below were tested only with GCC 4.4.1, and I'm only interested in them working with GCC.

你好,

我偶然发现了一些我不理解的对象构造语句,而且直到今天我才注意到它引入的模糊性.我将解释如何重现它,并想知道是否有办法解决它(允许C++ 0x).在这里.

假设有一个类,其构造函数只接受一个参数,而这个参数的类型是另一个具有默认构造函数的类.例如:

struct ArgType {};

class Class
{
public:
    Class(ArgType arg);
};

如果我尝试Class在堆栈上构造一个类型的对象,我会产生歧义:

Class c(ArgType()); // is this an object construction or a forward declaration
                    // of a function "c" returning `Class` and taking a pointer
                    // to a function returning `ArgType` and taking no arguments
                    // as argument? (oh yeh, loli haets awkward syntax in …

我很清楚,一般的经验法则是你应该只导入必要的 - 基类接口,协议接口等 - 用于编译和使用@class可以向前声明的所有内容的类.但是,我遇到了以下情况,我觉得这#import是一个更合适的解决方案:

#import "ClassA.h"      // Previously, @class ClassA;
#import "ClassB.h"      // Previously, @class ClassB;
#import "ClassC.h"      // Unnecessary to forward-declare

@interface ClassD : NSObject

@property (nonatomic, retain) ClassA *  classAObject;
@property (nonatomic, retain) ClassB *  classBObject;
@property (nonatomic, copy)   NSArray * classCObjects;

@end

起初,我只是向前声明ClassA和ClassB(作为的成分classCObjects是ClassC由合同只).这是我最初的直觉.

但是,试图使用后ClassD在其他地方,我很快就意识到,我必须也进口ClassA,ClassB和ClassC沿着ClassD到处我用它.这似乎是另一个类在使用时不应该关心的东西ClassD.我的想法是,基本上,一个用户ClassD应该真的只关心导入ClassD.h并假设它可以在没有一堆其他#import语句的情况下使用整个类.鉴于上述方法,我基本上已经包含了ClassD在其界面中正确的域内工作所需的一切. …

可能重复:
未命名结构的前向声明

如果我有

typedef struct tagPAGERANGE
{
    int iFirstPage;
    int iLastPage;
} PAGERANGE;

我可以这样宣布它

struct tagPAGERANGE;
typedef struct tagPAGERANGE PAGERANGE;

但我拥有的是

typedef struct
{
    int iFirstPage;
    int iLastPage;
} PAGERANGE;

我不知道怎么做.我只想拥有一个指向这个结构的指针.现在我坚持要么包含一个相当实质的标题,要么重复结构的定义.

我正在努力学习如何处理很多包含,并且仍然保持我的代码整洁.

我正在编写一个Qt应用程序,我把常用的文件(并没有改变)放在一个名为"Util.h"的文件中.

Util.h

#pragma once

#include <Core/IObserver.h>
#include <Core/Math.h>
#include <QAction>
#include <QDockWidget.h>
#include <QFileDialog>
#include <QGraphicsBlurEffect>
#include <QLabel.h>
#include <QMainWindow.h>
#include <QMenu.h>
#include <QMessageBox.h>
#include <QShortcut.h>
#include <QSignalMapper>
#include <QSound>
#include <QString>
#include <QTimer.h>
#include <QTreeView>
#include <QStandardItemModel>


// Path to icons
#define ICON_PATH                                               \
    "../../Assets/GUI/Icons/"

然后我将它包含在几乎所有的头文件中

#include "Util.h"
#include "Manager_Docks.h"
#include "Manager_Tools.h"
#include "Manager_Console.h"
#include "ui_MainWindow.h"
...

• 有没有更好的方法呢？
• 这会减慢编译时间吗？

我也想到只在每个.cpp中都包含Util.h,并且对于头文件有一个单独的Header_Util.h,看起来像这样

Header_Util.h

#pragma once

class IObserver;
class QAction;
class QDockWidget;
class QFileDialog; …

我有一个第三方C库,其匿名结构类似于

    typedef struct
     {
      ...
      }A;

该文件是通过程序自动生成的,因此可以根据某些内容进行更改

现在在C++项目中,我接受上述类型的参数,例如as

  void foo(const A & in)
  {
    ...
  }

如何在定义上述函数的头文件中转发声明A？

我试过了 :

 typedef struct A A;

要么

 struct A;

并且

 typedef A A;

出于好奇.

但是,这会导致重新定义类型的编译时错误.谢谢

我有MyClassA一个类型的属性MyClassB

//
//  MyClassA.h
//  

@interface MyClassA : NSObject

@property (strong, nonatomic, readonly) MyClassB *myClassB;

@end

MyClassB有房产myString.

//
//  MyClassB.h
//  

@interface MyClassB : NSObject

@property (copy, nonatomic, readonly) NSString *myString;

@end

我有MyClassC需要访问myString它的实现.

我是不是该 -

一)正向声明MyClassB中MyClassA.h,并#import "MyClassB.h"在MyClassC.m

要么

b)#import MyClassB.hinMyClassA.h

我曾尝试在程序中为动态变量定义变量类型，但似乎无法使它存储将其返回为类型的函数。

using Value = std::variant<Integer, Float, Function>;
using Function = std::function<Value()>;

由于Function需要在当时定义，因此不会编译Value，但也Function取决于它Value。我尝试通过将Function类型内联到变量模板列表中来解决此问题，但似乎using语句无法引用自身或进行正向声明。

到目前为止，我最好的解决方案是将其定义Function为结构，以便我可以对其进行声明。这行得通，但似乎太笨拙了，所以我想知道是否有更好的方法？

struct Function;
// define Value
struct Function : std::function<Value()> {};

为了阐明这一点，它std::function被用作示例的一部分，因为我认为这样可以更轻松地展示我正在尝试做的事情，而对于我的hacky解决方案来说，这也是需要的。如果可能的话，我更希望有一种使用普通函数指针的方法。

我正在开发一个当前支持Python 3.6+ 的库，但在如何在 Python 3.6 的模块中定义前向引用方面遇到了一些麻烦typing。我已经pyenv在本地 Windows 计算机上进行了设置，以便可以轻松地在不同的 Python 版本之间切换以进行本地测试，因为我的系统解释器默认为 Python 3.9。

这里的用例本质上是我尝试使用TypeVar有效的前向引用类型定义 a ，然后我可以将其用于类型注释目的。我已经确认当我在 3.7+ 上并直接从模块导入时，以下代码运行没有问题，但我无法在 Python 3.6 上获取它，因为我注意到前向引用不能用作某些参数原因。我还尝试将前向引用类型作为参数传递给，但遇到了类似的问题。ForwardReftypingTypeVarUnion

TypeVar以下是我试图在 python 3.6.0 以及更新版本（如 3.6.8）上工作的导入和定义- 我确实注意到我在次要版本之间遇到了不同的错误：

from typing import _ForwardRef as PyForwardRef, TypeVar


# Errors on PY 3.6:
#   3.6.2+ -> AttributeError: type object '_ForwardRef' has no attribute '_gorg'
#   3.6.2 or earlier -> AssertionError: assert isinstance(a, GenericMeta)
FREF = TypeVar('FREF', str, PyForwardRef)

下面是我已经测试过的示例用法，它似乎按照 Python …