1

在下面的程序中，我使用了一个名为 check 的布尔变量，它在 main 函数中被 Tst1 和 Test2 两个对象访问。但是程序中不维护检查变量的值。我们可以使用静态，但我想知道一些替代方式..有人能给我一些提示吗？提前致谢 。

在jointdetails.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)
{
}

内部分析器.h

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

内部分析器.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;


}

Test1.h 内部

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

Test1.cpp 内部

#include "Tst1.h"

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

Tst1::~Tst1(void)
{
}

Test2.h 内部

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

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 ;
}
4

3 回答 3

1

这样做只有两种可能的方法：

  1. 使用static存储数据
  2. 将自动或动态存储数据作为参数传递给目标函数/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();
 }

分析器.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; }
};
于 2012-09-02T20:36:14.473 回答
0

您要么必须将 check 设为静态，要么将 JointDetails 设为单例（也使用 static 关键字）。

如果您将检查设为静态，则表示 JointDetails 的所有实例都具有相同的检查。

如果您将 JointDetails 设为单例，那么您就是说对 JointDetails 对象的每个引用都是同一个对象，因此您的 Tst1 和您的 Test2 都将具有指向同一个对象的指针。

我认为后者是你正在寻找的：

联合详情.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;
}

分析器.cpp

Analyzer::Analyzer(void)
{
    m_ptheCTJointDetails = Jointdetails::getInstance();
}
于 2012-09-02T18:32:38.300 回答
0

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;
}
于 2012-09-02T18:53:29.193 回答