Question

在下面的程序中，我使用一个名为check的布尔变量，该函数在主函数内由Tst1和Test2的两个对象访问。但是程序中没有维护check变量的值。我们可以使用静态，但我想知道一些替代方法..有人能给我一些提示吗？提前谢谢。

在jointdeatils.h内部

#pragma once

class Jointdetails
{
public:
    Jointdetails(void);
    ~Jointdetails(void);
    bool check;


};

在jointdeatils.cpp内部

#include "Jointdetails.h"

Jointdetails::Jointdetails(void)
{
    check = false ;
}

Jointdetails::~Jointdetails(void)
{
}

Inside analyzer.h

#pragma once
#include "Jointdetails.h"
class Analyzer
{
public:
    Analyzer(void);
    Jointdetails* GetJointDetails();
    Jointdetails* m_ptheCTJointDetails;
    ~Analyzer(void);
};

Inside analyzer.cpp

#include "Analyzer.h"
#include "stddef.h"
Analyzer::Analyzer(void)
{
    m_ptheCTJointDetails = new Jointdetails();

}

Analyzer::~Analyzer(void)
{
}
Jointdetails* Analyzer::GetJointDetails()
{

    if(m_ptheCTJointDetails) 
        return m_ptheCTJointDetails;
    else
        return NULL;


}

Inside Test1.h

#pragma once
#include "Analyzer.h"
class Tst1
{
public:
    Tst1(void);
    Analyzer *analyzer1 ;
public:
    ~Tst1(void);
};

Inside Test1.cpp

#include "Tst1.h"

Tst1::Tst1(void)
{
    analyzer1 = new Analyzer ;
}

Tst1::~Tst1(void)
{
}

Inside Test2.h

#pragma once
#include "Analyzer.h"
class Test2
{
public:
    Test2(void);
    Analyzer *analyzer2 ;
public:
    ~Test2(void);
};

Inside Test2.cpp

#include "Test2.h"

Test2::Test2(void)
{
    analyzer2 = new Analyzer ;
}

Test2::~Test2(void)
{
}

在main.cpp内部

#include "Test2.h"
#include "Tst1.h"
#include "stdio.h"

int main()
{
    Tst1 *test1 = new Tst1 ; //check = false
    Test2 *test2 = new Test2 ; //check = false
    test1->analyzer1->GetJointDetails()->check = true ;
    if(test2->analyzer2->GetJointDetails()->check )
        printf("Check value is changed");
    else
        printf("Check value is not changed");
        return 0 ;
}

Answer 1

只有两种可能的方法：

使用static存储数据
将自动或动态存储数据作为参数传递到目标函数/ ctors

方式＃1更方便，因为您可以直接从任何功能访问此类数据。但它应被视为糟糕的设计，因为它与邪恶的全局变量几乎相同。

方式＃2更正确（例如，请参见justin的回答）但可能有点恼人 - 您需要将所需数据作为参数传递给每个所需函数和/或将数据存储为类数据成员。在许多类/嵌套调用的情况下，这不是一件令人愉快的工作。

尽管如此，如果你不关心方式＃1的缺点，可以考虑单点按需概念。它允许以更动态的方式使用静态数据 - 按需创建，由多个用户共享访问权限，并在任何人不再使用时销毁。参见示例（为简洁起见，跳过了几个细节，包括等等）：

JointDetails.h

 class JointDetails
 {
    // Actual class definition
    // ...
 public:

    // Function accessing to JointDetails instance
    static std::shared_ptr<JointDetails> Get();
 };

JointDetails.cpp

 std::shared_ptr<JointDetails> JointDetails::Get()
 {
    static std::weak_ptr<JointDetails> s_trackInstance;
    if(s_trackInstance.expired())
    {
       auto instance = std::make_shared<JointDetails>();
       s_trackInstance = instance;
       return instance;
    }

    return s_trackInstance.lock();
 }

Analyzer.h

// All instances of Analyzer share the same instance of JointDetails.
// But JointDetails instance is created dynamically only when first instance of
// Analyzer is created and destoyed when the last instance of Analyzer is destroyed.
class Analyzer
{
   std::shared_ptr<JointDetails> m_details;
public:
   Analyzer(): m_details(JointDetails::Get()) {}
   const JointDetails& GetDetails() const { return *m_details; }
};

Answer 2

您要么必须进行静态检查，要么将JointDetails作为单例（也使用static关键字）。

如果你检查静态，你说的是JointDetails的所有实例都有相同的检查。

如果你使JointDetails成为一个单例，那么你就是说每个对JointDetails对象的引用都是同一个对象，所以你的Tst1和你的Test2都有一个指向同一个对象的指针。

我认为后者正是您所寻找的：

Jointdetails.h

#pragma once

class Jointdetails
{
public:
    ~Jointdetails(void);
    bool check;

    static Jointdetails* getInstance();
private:
    Jointdetails(void);
};

Jointdetails.cpp

#include "Jointdetails.h"

Jointdetails::Jointdetails(void)
{
    check = false ;
}

Jointdetails::~Jointdetails(void)
{
}

Jointdetails* Jointdetails::getInstance() {
    static Jointdetails s_instance;
    return &s_instance;
}

Analyzer.cpp

Analyzer::Analyzer(void)
{
    m_ptheCTJointDetails = Jointdetails::getInstance();
}

Answer 3

0）您不需要经常使用new。

1）您可以使用关节细节作为构造函数中的参数来构造对象。

举例说明：

class Tst1 {
public:
  Tst1(Jointdetails& pJointdetails) : analyzer1(pJointdetails) {
  }

  Analyzer analyzer1;
public:
  ~Tst1(void);
};

int RunProgram(Jointdetails& pJointdetails) {
  Tst1(pJointdetails);
  ...
}

int main() {
  Jointdetails jointdetails;
  const int result(RunProgram(jointdetails));
  return result;
}

在不使用静态关键字的情况下使整个程序中的数据成员保持一致

3 个答案: