이상한 메서드 동작

Question

퍼지 논리를 사용하여 로봇 자동차를 제어하는 ​​내 Arduino 용 프로그램을 작성하려고합니다. 하지만 C++에 관한 문제가 생겼습니다.

double FRule::dof(double x1,double x2){ 
    pi1 = ant1->getFSet(U1)->lom(x1); //ant1 is a TermSet  
    pi2 = ant2->getFSet(U2)->lom(x2); //ant2 is a TermSet   
    Serial.println(pi1); 
    Serial.println(pi2); 
    return min(pi1,pi2);; 
} 

내가 직접 FSet 개체에 대한 lom 메소드를 호출 생각하면, 나에게 바로 결과를 제공합니다 : I는 다음과 같습니다 내 클래스 FRule의 방법이있다. 하지만 FRule 방법 dof을 통해 전화를 시도하면 잘못된 결과가 표시되고 확실하지 않습니다. 왜 이런 일이 발생합니까?

아이디어가 있으십니까? 전체 프로그램의

출처 :

FSet::FSet(double center, double delta, int inf){ 

this->inf = inf; 
this->delta = delta; 
this->a = center - delta; 
this->b = center + delta; 
this->center = center; 
} 

double FSet::lom(double crispValue) { 
if(inf == 0){ 
    if((crispValue < this->a) || (crispValue > this->b)){ 
     return 0.0; 
    } else { 

     return 1 - abs(crispValue-center)*(1.0/delta); 
    } 
} else { 
    if(((crispValue < this->a) && (inf > 0)) || 
      ((crispValue > this->b) && (inf < 0))){ 
      return 0.0; 
    } 

    if((inf > 0) && (crispValue < center)){ 
     return 1 - abs(crispValue-center)*(1.0/delta); 
    } else if((inf < 0) && (crispValue > center)){ 
     return 1 - abs(crispValue-center)*(1.0/delta); 
    } else { 
     return 1.0; 
    } 

} 
} 

TermSet 클래스 :

TermSet::TermSet(float a, float b, float step, int setsSize){ 
this->a = a; 
this->b = b; 
this->step = step; 
this->last = -1; 

this->setsSize = setsSize; 
this->sets = (FSet**) malloc(sizeof(FSet*) * setsSize); 
this->size = (b-a)/step + 1; 
} 

TermSet::~TermSet(){ 
    free(this->sets); 
} 

FSet* TermSet::getFSet(int index){ 
     return this->sets[index]; 
} 

int TermSet::addFSet(FSet* set){ 
    sets[++last] = set; 
    return last; 
} 

double TermSet::getUODValue(int index){ 
    return a + index*step; 
} 

int TermSet::UODSize(){ 
    return size; 
} 

이 ** 내가 만든 코멘트 **

FSET 클래스에 따라 일부 변경 FRule 클래스

FRule::FRule(TermSet* ant1, int u1, TermSet* ant2, int u2, TermSet* conTermSet, int d){ 
    this->ant1 = ant1; 
    this->ant2 = ant2; 
    this->con = conTermSet; 
    this->U1 = u1; 
    this->U2 = u2; 
    this->D = d; 

    pi1 = 0.0; 
    pi2 = 0.0; 
    cdof = 0.0; 
} 

double FRule::dof(double x1,double x2){ 
    pi1 = ant1->getFSet(U1)->lom(x1); //ant1 is a TermSet  
    pi2 = ant2->getFSet(U2)->lom(x2); //ant2 is a TermSet   
    Serial.println(pi1); 
    Serial.println(pi2); 
    return min(pi1,pi2);; 
} 

개 그리고 마지막으로 응용 프로그램 코드

FSet errN(-2,2,-1); 
FSet errZ(0,2,0); 
FSet errP(2,2,1); 

FSet errDtN(-0.5,0.5,-1); 
FSet errDtZ(0,0.5,0); 
FSet errDtP(0.5,0.5,1); 

FSet cntN(-4,4,-1); 
FSet cntZ(0,4,0); 
FSet cntP(4,4,1); 

TermSet errDt(-1,1,0.1,3); 
TermSet err(-3,3,1,3); 
TermSet cnt(-6,6,1,3); 


void loop(){ 

    errDt.addFSet(&errDtN); 
    int ierrDt = errDt.addFSet(&errDtZ); 
    errDt.addFSet(&errDtP); 

    err.addFSet(&errN); 
    int ierr = err.addFSet(&errZ); 
    err.addFSet(&errP); 

    cnt.addFSet(&cntN); 
    cnt.addFSet(&cntZ); 
    cnt.addFSet(&cntP); 

    FRule rule1(&err,ierr,&errDt,ierrDt,&cnt,1); 

    Serial.print("UOD SIZE: "); 
    Serial.println(errDt.UODSize()); 

    Serial.print("LOM1: "); 
    Serial.println(errZ.lom(0)); 

    Serial.print("LOM2: "); 
    Serial.println(errDtZ.lom(-0.1)); 

    Serial.print("DOF: "); 
    Serial.println(rule1.dof(0,-0.1)); 

    delay(10000); 

} 

헤더 파일 :

class FSet { 
    public: 
     FSet(double center, double delta, int inf);   
     // Returns Level Of Matching (value of the membership function) for the given x 
     double lom(double crispValue);   
     // Start of UOD 
     double a; 
     // End of UOD 
     double b;   
    private:   
     double center; 
     ouble delta; 
     int inf;   
}; 

class TermSet { 

public: 
    TermSet(float uodA, float uodB, float step, int setsSize); 
    ~TermSet(); 
    FSet* getFSet(int index); 
    int addFSet(FSet* set); 
    double getUODValue(int index); 
    int UODSize(); 

    FSet** sets; 
    int setsSize; 
    float a = 0; 
    float b = 0; 
    float step; 
    int size = 0; 
private: 
    int last; 
}; 

class FRule { 
    public: 
     FRule(TermSet* ant1, int u1, TermSet* ant2, int u2, TermSet* conTermSet, int d); 
     double dof(double x1,double x2); 
     double* ruleOutput(double x1, double x2); 
     TermSet* ant1; 
     TermSet* ant2; 
     TermSet* con; 
     double cdof; 
     double pi1; 
     double pi2; 
    private: 
     int U1; 
     int U2; 
     int D; 

}; 

Answer 1

는 자, 여기 size가 초기화되지 않은 변수이 시점에서 버그

TermSet::TermSet(float a, float b, float step, int setsSize){ 
this->a = a; 
this->b = b; 
this->step = step; 
this->last = -1; 

this->setsSize = size; 

입니다. 컴파일러에서 경고해야합니다. 컴파일러 경고에주의하십시오. 당신이 의미하는 것 같아요

this->setsSize = setsSize; 

당신이 가지고있는 문제의 원인인지는 모르겠지만, 우리에게 많은 것을주지 않았습니다.