C++；全局变量与Java实例变量 我有一个关于C++中全局变量的问题。我来自Java背景，您可以像这样声明和使用实例变量：

Example.java

class Example
{
   int x;

   doSomththing()
   {
      x = 1;
   }

   doSomethingElse()
   {
      x = 2;
   }
}

我的问题是，在C++中，如果我做了类似的事情，它会被归类为全局变量或实例变量。观察我的C++例子来澄清：

例h

class Example{

public:
void do_something();
void do_somethingElse();

private:
int x;

};

Example.cpp

#include Example.h

void Example::do_something()
{
    x = 1;
}

void Example::do_somethingElse()
{
    x = 2;
}

#include Example.h

static int g_value = 17;
extern int g_another_value;

void Example::do_something()
{
    x = g_value + g_another_value + 1;
}

void Example::do_somethingElse()
{
    x = g_value - g_another_value + 2;
}

---

<>那么，在C++示例中，x是全局变量还是实例变量？如果它不是一个全局变量，那么如何将x正确定义为一个全局变量？

因为x不一样，如果您创建一个新的示例实例，它就是一个实例变量。如果希望在示例的所有实例之间共享x，则应将其定义为

静态
，因为如果创建示例的新实例，x不相同，它是一个实例变量。如果希望在示例的所有实例之间共享x，则应将其定义为
静态
，就像在Java或C#中一样，x也是一个实例变量。无论好坏，C++允许类定义之外的变量，如：
class Example{

public:
    void do_something();
    void do_somethingElse();

private:
    int x;
};

Example.cpp

#include Example.h

void Example::do_something()
{
    x = 1;
}

void Example::do_somethingElse()
{
    x = 2;
}

#include Example.h

static int g_value = 17;
extern int g_another_value;

void Example::do_something()
{
    x = g_value + g_another_value + 1;
}

void Example::do_somethingElse()
{
    x = g_value - g_another_value + 2;
}

OtherCode.cpp

int g_another_value = 31;
// other code

在这种情况下，static关键字将只允许作用域访问此文件，但是删除static并在关键字extern前面的其他cpp文件中重新声明变量将使编译器感到高兴，并且链接器将解析该变量

希望这有帮助。
就像在Java或C#中一样，x也是一个实例变量。无论好坏，C++允许类定义之外的变量，如：
class Example{

public:
    void do_something();
    void do_somethingElse();

private:
    int x;
};

Example.cpp

#include Example.h

void Example::do_something()
{
    x = 1;
}

void Example::do_somethingElse()
{
    x = 2;
}

#include Example.h

static int g_value = 17;
extern int g_another_value;

void Example::do_something()
{
    x = g_value + g_another_value + 1;
}

void Example::do_somethingElse()
{
    x = g_value - g_another_value + 2;
}

OtherCode.cpp

int g_another_value = 31;
// other code

在这种情况下，static关键字将只允许作用域访问此文件，但是删除static并在关键字extern前面的其他cpp文件中重新声明变量将使编译器感到高兴，并且链接器将解析该变量

希望这能有所帮助。
在C/C++中声明一个全局变量，只需将它放在顶级，任何类语句之外，这在Java中是不可能的

int y;

示例中的变量
x
显然是一个实例变量。除了可见性（private vs.package）之外，它完全等同于Java示例中的
x
。
在C/C++中声明一个全局变量，只需将它放在顶层，任何类语句之外，这在Java中是不可能的

int y;

示例中的变量
x
显然是一个实例变量。除了可见性（私有vs包），java示例中的C++和x>代码不完全等同。
 首先，您应该知道java实例不能翻译为1:1到C++，因为C++不知道<>强>包私有访问性<强>（实际上，C++在语言层上没有真正的包，并且将它们添加到语言中的建议并没有使它成为C++ 11）。您的类<代码>示例及其<代码> x>代码>字段和方法是包私有的，这意味着它们被隐藏在包外的任何代码中。
C++只知道
public
、
protected
和
private
，它们在很大程度上（但不是完全！）对应于它们的Java等价物，但它也知道friend函数和类，有时可以使用它们来实现类似于包私有可访问性的结果

除了这个可访问性问题，C++实例中的x/Cuff>变量与java示例中的变量相同，即它是一个实例变量，在每个实例中都有单独的值。
全局变量在C++中是可能的，但是正如你可能已经知道的，它们通常是坏的设计。想象一下这个完整的C++程序：
int x; // global variable, usually bad

int main()
{
  x = 123;
}

这是否意味着java可以阻止这种糟糕的设计？不，它没有。它屏蔽了C++中全局变量的一些令人惊讶的危险低层次方面（请阅读更多有关细节的内容）。但是，C++的.<强>公共公共变量不是最终的<强>，它很像C++中的一个普通的全局变量。
以以下Java代码为例：
public class Example {
    public static int x; // hardly better than a global variable in C++
}

<>这比C++中的“真实”全局变量好，整个程序中的每一段代码都可以访问它，这会增加紧耦合性，影响可测试性。
下面是Java中伪装的坏全局变量的另一个示例：

public class Singleton {
    private static final Singleton INSTANCE = new Singleton();

    private int x; // global variable in disguise

    private Singleton() {
    }

    public static Singleton getInstance() {
        return INSTANCE;
    }

    public int getX() {
        return x;
    }

    public void setX(int newX) {
        x = newX;
    }
}

class Example
{
public:
    static int x; // global variable in disguise
};

（是的，在我所见过的任何一段代码中，99%的情况下，单例设计模式只不过是一个美化的全局变量。）

P> >点：技术上java没有像C++ C++那样的全局变量，但是不难模仿它们的行为和缺陷，然后它们就完全一样坏（减去C++中存在的一些低级别初始化问题）。它们看起来更漂亮、更干净，周围的所有类东西，尤其是初学者。

顺便说一下，你也可以在C++中实现单（反）模式，而且它通常也不只是一个美化的全局变量：

class Singleton
{
private:
    static Singleton *instance;
    int x; // global variable in disguise
    Singleton() : x(0) {}
public:
    static Singleton &instance()
    {
        // ignoring any concurrency issues for
        // simplicity's sake, don't try this at
        // home

        if (instance == nullptr)
        {
            instance = new Singleton;
        }
        return *instance;
    }

    void setX(int newX) { x = newX; }
    int getX() const { return x; }
};

您还可以通过组合使用
static
、
public
和non-
const
创建一个更简单的全局变量，就像在Java中一样：

public class Singleton {
    private static final Singleton INSTANCE = new Singleton();

    private int x; // global variable in disguise

    private Singleton() {
    }

    public static Singleton getInstance() {
        return INSTANCE;
    }

    public int getX() {
        return x;
    }

    public void setX(int newX) {
        x = newX;
    }
}

class Example
{
public:
    static int x; // global variable in disguise
};


只想说清楚：
静态
并不是邪恶的。但你必须知道在哪里应用它，你必须意识到，
公共
、
静态
和非
最终
/non-
常量
的组合通常是对“真实”的（善意但短视的）替代在java和C++ C++中，首先，你应该知道你的java示例不能翻译成1:1到C++，因为C++不知道<强>包私有可访问性<强>（实际上，C++在语言层上没有真正的包，并且建议将它们添加到语言中并没有使它成为C++ 11）。.您的类
示例