如何在不同的类中修改同一个变量并进行修改?
How to modify the same variable in different classes and modify it?
我有许多函数定义,我将它们放在不同的 cpp 文件中,函数声明在它们各自的 .h 文件中。
我有一组变量,已放在 .h 文件中。这些变量需要被不同的函数修改。我正在使用 static 来保留每个函数的更改,但我听说这是一种糟糕的编码习惯。不然怎么办?例如 -
variables.h
class variable{
static int x;
static int y;
};
function1.h
class function(){
public:
void function1();
}
功能 2 相似
函数1.cpp
void function1(){
// does something with x and y (used as (variable::x=2;variable::y=3)
}
function2.cpp
void function2(){
// does something with x and y (used as variable::x+=2;variable::y+=2)
}
main.cpp
int variable::x;
int variable::y;
int main(){
obj.function1(); (obj is object of function1 class)
obj2.function2(); (obj2 is object of function2 class)
cout << variable::x << variable::y << endl;
}
我在不同的 cpp 文件中使用了不同的对象,但一个函数的变化并没有反映在其他函数中。怎么用请帮忙?
您可以简单地将这些变量移动到另一个 class:
struct Shared {
int x;
int y;
};
现在您可以将一个实例传递给此 class 作为函数的参数,这称为依赖注入:
void foo(Shared& shared) {
shared.x = 4;
shared.y = 2;
}
这样更好,因为您不再有任何全局状态。通过引用 Shared
class.
的不同实例,您可以多次独立使用该函数
通过在 class 的构造函数中“注入”实例来更进一步是很常见的。如果 class 的实例应始终引用相同的实例,这将很有帮助:
struct Foo {
Shared& m_shared;
Foo(Shared& shared)
: m_shared(shared)
{
}
void foo() {
m_shared.x = 4;
m_shared.y = 2;
}
};
是的,正如您提到的,为此目的使用静态变量有点 anti-pattern。更好的模式(在不知道应用程序背景的情况下)是使用组合模式。如果你的函数 f1() 和 f2() 在 类 C1 和 C2 中,你会 e. G。创建一个额外的数据对象 D1(带有相关变量),并在 C1 和 C2 的构造函数中注入 D1 的对象,因此两者都对数据对象进行 类 操作。对于这种情况还有其他解决方案,但我想这是最通用的。 Google 用于 C++ 设计模式以找到更通用的模式。
您可以对全局对象使用智能指针
struct MyGlobal
{
std::shared_ptr<Core> core;
MyGlobal(){ core=std::make_shared<Core>(); }
void changeVariableX(int X)
{
core->X = X;
}
};
您可以移动、复制、使用 MyGlobal 实例做任何您想做的事情,它们仍然指向相同的核心项目。只需确保所有这些都是从同一个实例中填充的,如下所示:
int main()
{
MyGlobal global;
auto something = useSomeFunctionWith(global);
auto somethingElse = useAnotherFunctionWith(global);
...
// use something and somethingElse to change X, both point to the same X
}
如果函数不是 thread-safe 那么您应该将 lock-guard 添加到 changeVariableX 方法中。
我有许多函数定义,我将它们放在不同的 cpp 文件中,函数声明在它们各自的 .h 文件中。
我有一组变量,已放在 .h 文件中。这些变量需要被不同的函数修改。我正在使用 static 来保留每个函数的更改,但我听说这是一种糟糕的编码习惯。不然怎么办?例如 -
variables.h
class variable{
static int x;
static int y;
};
function1.h
class function(){
public:
void function1();
}
功能 2 相似
函数1.cpp
void function1(){
// does something with x and y (used as (variable::x=2;variable::y=3)
}
function2.cpp
void function2(){
// does something with x and y (used as variable::x+=2;variable::y+=2)
}
main.cpp
int variable::x;
int variable::y;
int main(){
obj.function1(); (obj is object of function1 class)
obj2.function2(); (obj2 is object of function2 class)
cout << variable::x << variable::y << endl;
}
我在不同的 cpp 文件中使用了不同的对象,但一个函数的变化并没有反映在其他函数中。怎么用请帮忙?
您可以简单地将这些变量移动到另一个 class:
struct Shared {
int x;
int y;
};
现在您可以将一个实例传递给此 class 作为函数的参数,这称为依赖注入:
void foo(Shared& shared) {
shared.x = 4;
shared.y = 2;
}
这样更好,因为您不再有任何全局状态。通过引用 Shared
class.
通过在 class 的构造函数中“注入”实例来更进一步是很常见的。如果 class 的实例应始终引用相同的实例,这将很有帮助:
struct Foo {
Shared& m_shared;
Foo(Shared& shared)
: m_shared(shared)
{
}
void foo() {
m_shared.x = 4;
m_shared.y = 2;
}
};
是的,正如您提到的,为此目的使用静态变量有点 anti-pattern。更好的模式(在不知道应用程序背景的情况下)是使用组合模式。如果你的函数 f1() 和 f2() 在 类 C1 和 C2 中,你会 e. G。创建一个额外的数据对象 D1(带有相关变量),并在 C1 和 C2 的构造函数中注入 D1 的对象,因此两者都对数据对象进行 类 操作。对于这种情况还有其他解决方案,但我想这是最通用的。 Google 用于 C++ 设计模式以找到更通用的模式。
您可以对全局对象使用智能指针
struct MyGlobal
{
std::shared_ptr<Core> core;
MyGlobal(){ core=std::make_shared<Core>(); }
void changeVariableX(int X)
{
core->X = X;
}
};
您可以移动、复制、使用 MyGlobal 实例做任何您想做的事情,它们仍然指向相同的核心项目。只需确保所有这些都是从同一个实例中填充的,如下所示:
int main()
{
MyGlobal global;
auto something = useSomeFunctionWith(global);
auto somethingElse = useAnotherFunctionWith(global);
...
// use something and somethingElse to change X, both point to the same X
}
如果函数不是 thread-safe 那么您应该将 lock-guard 添加到 changeVariableX 方法中。