是否有可能避免在实现文件重复类名？是否有可能避免在实现文件重复类名？(Is it possible

Is there a way to avoid the Graph:: repetition in the implementation file, yet still split the class into header + implementation? Such as in:

Header File:

#ifndef Graph_H
#define Graph_H

class Graph {
public:
    Graph(int n);
    void printGraph();
    void addEdge();
    void removeEdge();
};

#endif

Implementation File:

Graph::Graph(int n){}
void Graph::printGraph(){}
void Graph::addEdge(){}
void Graph::removeEdge(){}

Answer 1:

我猜这是为了避免大量的“不必要的打字”的。可悲的是有没有办法摆脱的范围（如许多其他的答案都告诉你），但是我做什么亲自为获得与漂亮的行中的所有我的函数原型定义的类，然后复制/粘贴到实现文件，然后按Ctrl-C你的类名::在剪辑板并运行了CTRL-v线。

Answer 2:

如果你想避免在printGraph面前，addEdge等键入“图形::”，那么答案是“没有”，很遗憾。在“局部类”的功能类似于C＃是不是在C ++访问任何类（如“图”）的名称是不是一个命名空间，这是一个范围。

Answer 3:

没有有没有。不能直接最少。你可以去预处理器技巧，但不这样做 。

#define IMPL Graph::

IMPL Graph(int n){}
void IMPL printGraph(){}
void IMPL addEdge(){}
void IMPL removeEdge(){}

此外，你甚至不应该想这样做。重点是什么。除了它是一个C ++的规则，它可以让你知道你在实际执行的成员函数。

Answer 4:

没有，有没有办法避免。否则，你怎么会知道，如果给定函数定义为一类函数或静态函数？

Answer 5:

如果你问，如果你能定义一个成员函数如Graph::printGraph没有指定类名的资格，那么答案是，你不想要，没有办法的办法。这是不是在C ++可能：

实现文件：

void printEdge(){};

以上将编译就好了，但你想要什么也不会做。它不会由内相同的名称定义的成员函数Graph类。相反，它会声明和定义一个新的名为free函数printEdge 。

这是很好的和适当的，如果你的观点有点痛苦的，因为你可能希望使用相同的名称，但在不同的范围两个功能。考虑：

// Header File
class A
{
  void foo();
};

class B
{
  void foo();
};

void foo();

// Implementation File
void foo()
{
}

其范围应界定申请？ C ++不从具有在不同范围相同的名称不同的功能限制你，所以你必须要告诉你定义什么功能的编译器。

Answer 6:

        //yes it is possible using preprocessor like this:

        #define $ ClassName //in .cpp 

    void $::Method1() 
    { 
    } 

    //or like this: in the header .h:

        #undef $
        #define $ ClassName' 

// but you have to include the class header in last #include in your .cpp:

        #include "truc.h"
        #include "bidule.h" ...
        #include "classname.h" 

        void $::Method() { }  

        //i was using also 
        #define $$ BaseClass 
        //with single inheritance  than i can do this: 

        void $::Method() 
        { 
        $$::Method(); //call base class method 
        } 

        //but with a typedef defined into class like this it's better to do this: 
        class Derived : Base 
        { 
        typedef Base $$;  

    }

Answer 7:

编辑：我误解你的问题:(这将是一个问题的答案是否可以分割头-文件遗憾。

答案很简单：你可以先分割C ++ - 文件，但不能拆分头-文件。

原因很简单。每当你的编译器需要编译一个构造函数，它需要知道它究竟需要多少内存来分配这样一个对象。

例如：

class Foo {
   double bar;  //8 bytes
   int goo;  //4 bytes
}

“新的Foo（）”将需要12个字节内存的分配。但是，如果你被允许延伸到多个文件（即拆分头文件）你的类定义，你会很容易理解这一个烂摊子。你的编译器永远不会知道，如果你已经讲述了一个关于类的一切，还是你没有。在你的代码不同的地方可以让你的类的定义不同，导致无论是分段错误或极端cryptical编译器错误。

例如：

h1.h：

class Foo {
   double bar;  //8 bytes
   int goo;  //4 bytes
}

h2.h的：#include “h1.h”

class Foo {
   double goo;  //8 bytes
}// we extend foo with a double.

foo1.cpp：

#include "foo1.h"

Foo *makeFoo() {
   return new Foo();

}

foo2.cpp：

#include "foo2.h"

void cleanupFoo(Foo *foo) {
   delete foo;
}

foo1.h：

#include "h1.h"

Foo *makeFoo();

foo2.h：

#include "h1.h"
#include "h2.h"

void cleanupFoo(Foo *foo)

main.cpp中：

#include foo1.h
#include foo2.h

void main() {
    Foo *foo = makeFoo();
    cleanupFoo(foo);
}

现在，请仔细检查，如果你先编译main.cpp中到main.o，然后foo1.cpp到foo1.o和foo2.cpp到foo2.o，终于联系他们一起会发生什么。这应该编译，但makeFoo（）分配成才其他则cleanupFoo（）释放。

所以你有它，随意拆.cpp文件，但不要头文件分割补课。

文章来源: Is it possible to avoid repeating the class name in the implementation file?