Question

此问题来自this one。

我有一个工作程序，必须分成多个部分。在这个程序中，需要在程序的一部分中多次使用一个变量（现在它是一个GTK + one：P），这些变量将以分离的.cpp文件结束。

所以，我做了一个简单的例子来了解如何使程序部分的变量可用。以前代码的修改版本是：

#include <iostream>

using namespace std;

int entero = 10;

void function()
    {
    cout<<entero<<endl;
    //action1...;
    }

void separated_function()
    {
    cout<<entero<<endl;
    //action2...;
    }

int main( int argc, char *argv[] )
    {
    function();
    separated_function();
    cout<<entero<<endl;
    //something else with the mentioned variables...;
    return 0;
    }

需要正确拆分代码，将function()，another_function()和main()放在单独的.cpp文件中，并使entero可用于所有这些文件。 .. 但是：

在上一个问题中@NeilKirk评论说：Do not use global variables. Put the required state into a struct or class, and pass it to functions as necessary as a parameter（我还发现许多网页指向不建议使用全局变量）。

而且，据我所知，在@PaulH提供的答案中，他正在描述如何通过使变量成为全局来使变量可用。这个答案非常有用，它不仅适用于char数组，还适用于int s，string和GTK +变量（或指向变量的指针：P）。

但是由于不推荐这种方法，我要感谢任何能够展示将代码作为函数参数传递的代码的正确方法，或者比 - working - global变量更推荐的其他方法。

我研究了参数和类，但我是新手，我把代码搞砸了没有好结果。

感谢您的帮助。

Answer 1

如果您想要与全局变量

相同的comportement，则需要将参数作为参考

#include <iostream>

using namespace std;


// renamed the parameter to avoid confusion ('entero' is valid though) 
void function(int &ent)
{
    cout<<ent<<endl;
    ++ent; // modify its value
    //action1...;
}

void separated_function(int &ent)
{
    cout<<ent<<endl;
    ++ent; // modify its value again
    //action2...;
}

int main( int argc, char *argv[] )
{
    int entero = 10; // initializing the variable

    // give the parameter by reference => the functions will be able to modify its value
    function(entero);
    separated_function(entero);

    cout<<entero<<endl;
    //something else with the mentioned variables...;
    return 0;
}

输出：

10
11
12

Answer 2

我更喜欢为全球数据提供功能界面。

.h文件：

extern int get_entero();
extern void set_entero(int v);

.cpp文件：

static int entero = 10;

int get_entero()
{
   return entero;
}

void set_entero(int v)
{
   entero = v;
}

然后，在其他地方，使用这些功能。

#include "the_h_file"

void function()
{
    cout << get_entero() << endl;
    //action1...;
}

void separated_function()
{
    cout << get_entero() << endl;
    //action2...;
}

int main( int argc, char *argv[] )
{
    function();
    separated_function();
    cout<< get_entero() <<endl;
    //something else with the mentioned variables...;
    return 0;
}

Answer 3

在头文件中定义类或结构是可行的方法，然后在所有需要类或结构的源文件中包含头文件。如果多个源文件需要函数原型或预处理器宏，还可以在头文件中放置函数原型或预处理器宏，以及变量声明（例如extern int some_int_var;）和namespace声明。< / p>

定义类时不会出现多个定义错误，因为类是编译器要处理的概念，类本身永远不会传递给发生多个定义错误的链接器。

让我们举一个简单的例子，一个头文件和两个源文件。

首先是头文件，例如myheader.h：

#ifndef MYHEADER_H
#define MYHEADER_H
// The above is called include guards (https://en.wikipedia.org/wiki/Include_guard)
// and are used to protect the header file from being included
// by the same source file twice

// Define a namespace
namespace foo
{
    // Define a class
    class my_class
    {
    public:
        my_class(int val)
            : value_(val)
        {}

        int get_value() const
        {
            return value_;
        }

        void set_value(const int val)
        {
            value_ = val;
        }

    private:
        int value_;
    };

    // Declare a function prototype
    void bar(my_class& v);
}

#endif // MYHEADER_H

上面的头文件定义了一个名称空间foo，在名称空间中定义了一个类my_class和一个函数bar。

_{（对于像这样的简单程序，命名空间不是必需的，但对于较大的项目，它变得更加需要。）}

然后是第一个源文件，例如main.cpp：

#include <iostream>
#include "myheader.h"  // Include our own header file

int main()
{
    using namespace foo;

    my_class my_object(123);  // Create an instance of the class

    bar(my_object);  // Call the function

    std::cout << "In main(), value is " << my_object.get_value() << '\n';

    // All done
}

最后是第二个源文件，例如bar.cpp：

#include <iostream>
#include "myheader.h"

void foo::bar(foo::my_class& val)
{
    std::cout << "In foo::bar(), value is " << val.get_value() << '\n';
    val.set_value(456);
}

将所有三个文件放在同一个项目中，然后构建。您现在应该获得一个输出

的可执行程序

In foo::bar(), value is 123
In main(), value is 456

Answer 4

如果您不打算修改变量，通常可以将其变为全局变量。但是，最好使用const关键字声明它，以通知编译器它不应该被修改，如下所示：

const int ENTERO = 10;

如果您使用多个cpp文件，还可以考虑使用头文件作为结构和函数声明。

如果您打算修改变量，只需在函数参数中传递它。

如何使用类使变量可用于多个.cpp文件？

4 个答案: