정적 키워드를 사용하지 않고 전체 프로그램에서 데이터 멤버의 일관성을 유지

Question

아래 프로그램에서 check라는 부울 변수를 사용합니다.이 함수는 Tst1과 Test2의 두 개체로 주 함수 내에서 액세스됩니다. 그러나 프로그램에서 check 변수의 값은 유지되지 않습니다. 우리는 정적을 사용할 수 있지만 다른 대안을 알고 싶습니다. 누군가 나에게 힌트를 줄 수 있습니까? 미리 감사드립니다.

내부 jointdeatils.h

#pragma once 

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


}; 

내부 jointdeatils.cpp analyzer.cpp 내부 analyzer.h

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

내부

#include "Jointdetails.h" 

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

Jointdetails::~Jointdetails(void) 
{ 
} 

#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; 


} 

,691 엄마 내부 363,210

내부 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) 
{ 
} 

in.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

은 당신이 중 하나 (또한 정적 키워드를 사용) 싱글을 체크 정적 수 있도록해야 할 것, 또는 JointDetails 있습니다.

정적 검사를 수행하면 JointDetails의 모든 인스턴스가 동일한 검사를 수행한다고 표시됩니다.

JointDetails를 싱글 톤으로 만들면 JointDetails 객체에 대한 모든 참조가 동일한 객체이므로 Tst1과 Test2는 모두 동일한 객체에 대한 포인터를 갖게됩니다.

Jointdetails.h

#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(); 
} 

#pragma once 

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

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

Jointdetails.cpp을 : 나는 후자 생각

당신을 위해 무엇을 찾고있는 사람입니다

Answer 2

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

Answer 3

을 이렇게하는 두 가지 방법이 있습니다

1. 사용 static 저장 데이터를 대상 기능/ctors에 매개 변수로
2. 패스 자동 또는 동적 스토리지 데이터가

웨이 1은 사용자가 액세스 할 수 있으므로 편리합니다. 모든 기능에서 데이터를 직접 가져올 수 있습니다. 그러나 이것은 악의적 인 전역 변수와 거의 동일하기 때문에 나쁜 설계로 간주됩니다.

웨이 2가 더 정확합니다 (예를 들어 justin의 답변 참조). 약간의 자극이있을 수 있습니다. 필요한 데이터를 매개 변수로 전달하고 /하거나 클래스 데이터 멤버로 데이터를 저장해야합니다. 많은 클래스/중첩 호출의 경우에는 즐거운 작업이 아닙니다.

그럼에도 불구하고 # 1 방법의 단점에 신경 쓰지 않는다면 싱글 톤 주문형 개념을 고려하십시오. 보다 동적 인 방법으로 정적 데이터를 사용할 수 있습니다. 주문형 생성, 여러 사용자의 액세스 공유, 더 이상 사용하지 않는 사용자의 파괴. 예를 참조 (몇 가지 세부 사항 등은 간결함을 위해 생략 포함) :

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