标签: forward-declaration

我知道这些问题似乎含糊不清,但我想不出任何其他方式来表达它,但是,是否有可能做到这样的事情:

#include<iostream>

class wsx;

class wsx
{
public:
wsx();
}

wsx::wsx()
{
std::cout<<"WSX";
}

？

我经常使用前向类声明和指向这些类的指针.

我现在需要通过多个层传递函数指针.我更愿意将包含声明我的函数指针原型的头部包含在取消引用函数指针的模块中,而不是包含在简单地传递该指针值的每个层中.

这可能吗？

=====

从答复中我怀疑我没有明确地表达问题.我寻求类似于前瞻性声明.我们都同意我可以写:

foo;

void bar(foo*);

void waz(foo*p){bar(p); }

请注意,除了名称之外,waz对类foo一无所知.也许酒吧可以访问foo的完整描述.也许酒吧只会进一步传递.谁在乎？只有那些取消引用foo*的网站.所有其他网站只需要"class foo;".

同样地,我知道我可以写:

typedef void foo(int,double);

void bar(foo*);

void waz(foo*p){bar(p); }

不同之处在于,现在标识符foo不仅已知表示函数类型,而且还已经携带完整的签名/原型.这迫使我陷入两种不愉快的情景之一:

1)在多个站点克隆typedef(哎呀!脆弱!)2)将typedef粘贴在一个标题中,并将其包含在提到foo*的每个地方.

注意不对称:在数据对象的情况下,我只需要在我想要取消引用foo*的那些点上提供类foo的完整描述; 在函数的情况下,我需要提供完整的签名/原型,我想提到一个foo*.

那么无论如何要弥补这种不对称性？

我知道我能做到

class Foo;

可能

struct Bar;

和全球职能

bool IsValid(int iVal);

键入的枚举怎么样？在未申报的课程中输入的枚举怎么样？具有未声明的类的函数怎么样？那个未申报的课程中的静态成员怎么样？在未知的命名空间中这些怎么办？我错过了任何可以向前宣布的东西吗？

标题<iostream>有一个伴侣<iosfwd>,如果我只需要指针或对流的引用就足够了.后者是超载时的常见情况operator<<.

是否有STL容器的标题？我想定义几个是采取引用STL容器的功能,我不希望包括<vector>,<list>,<set>等.人.完整的,所以我可以参考这些类型.这个问题有标准,增强或其他解决方案吗？

如果我想使用指向类的指针而我不对其执行任何操作,我们可以转发声明该类.但如果恰好是typedef,为什么不允许呢？在下面的例子中,它仅编译我包含注释的代码,但为什么编译器想要在那时知道它？如何转发声明可能是typedef的内容.在c ++ 0x中这种行为有什么变化吗？

#include <iostream>
using namespace std;
/*
template<class T>
class temp;

typedef temp<int> later;
*/
class later;
void somefunc(later*);
int main()
{
  later* l;
  somefunc(l);
  return 0;
}
//The following is in someother file/compilation unit.
template<class T>
struct temp
{
  public:
    void print()
    {
        T t(5);
        std::cout<< "helloworld: " << t << std::endl;
    }
};
typedef temp<int> later;
void somefunc(later* l)
{
  l = new later();
  l->print();
}

如何解决以下循环依赖？

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; 

我正在用C++编写一个库.我的图书馆里有两门课,A而且B.我想隐藏A()任何引用我的库的代码中的构造函数.我也希望类B能够调用A()构造函数.

我来自C#背景,并且很少记住我的C++.在C#中,我只是将A()构造函数声明为internal.我已经读过,在C++中最接近的方法是friend声明和前向声明的组合.我该怎么做呢？以下是我的三个文件:

啊:

#pragma once
class A
{
    private:
        A();
};

BH

#pragma once
class A;
class B
{
    public:
        A createA();
};

B.cpp:

#include "A.h"
#include "B.h"

A B::createA()
{
    A result; //cannot access private member declare in class 'A'
    return result;
}

我试过把它添加到啊:

public: friend A createA();

我反而尝试将此添加到Ah并带有相应的前向声明:

public: friend A B::createA();

我反而尝试添加和extern class B;Ah并使B成为这样的类:

public: friend class B;

我不知所措. …

使用C++ 11的强类型enum,可以声明类的成员枚举,如下所示:

class X {
public:
    enum class E;
};

enum class X::E { a, b };

但是,在制作X类模板时:

template <typename T>
class X {
public:
    enum class E;
};

template <typename T>
enum class X<T>::E { a, b };

gcc 4.7.2和clang 3.0都抱怨"错误:'枚举X :: E'是枚举模板[-pedantic]"和"错误:枚举不能是模板".我认为相关的标准部分(事实上,这个问题来自于)是§14模板,其中第一段规定:

该声明在模板声明应

• 声明或定义函数或类,或
• 定义成员函数,成员类,成员枚举或类模板或嵌套在类模板中的类的静态数据成员,或者
• 定义类或类模板的成员模板,或
• 是一个别名声明.

(强调我的).这是一个编译器错误,还是我完全错误地解释了这个语句？

我在C++ 11中工作,包括用C++ 03实现的h文件.在h文件中我包含了枚举的枚举Foo.我想申报一个转发code.h并将其用于code.cpp:

header.h:

enum Foo {A=1};

code.h:

enum Foo : int; // also tried : unsigned int, long, short, unsigned short, char, unsigned char
void bar(Foo foo);

code.cpp:

#include header.h
void bar(Foo foo) { }

这是我编译时得到的错误(测试g ++ 4.8.5和g ++ 5.3.1):

In file included from code.cpp:2:0:
header.h:1:6: error: underlying type mismatch in enum ‘enum Foo’
 enum Foo {A=1};
      ^
In file included from code.cpp:1:0:
code.h:3:12: error: previous definition here
 enum Foo : int;

如果我将header.h更改为:我可以修复此错误: …

当我尝试这个例子时：

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...

它会抛出编译错误。

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