Array mit defines initialisieren



  • Hallo Leute,

    ich hoffe ihr könnt mir helfen 🙂

    Ich stehe die ganze Zeit vor einem Problem, wo ich den Fehler einfach nicht finde, der bestimmt banal ist 🙄

    Ich habe mehrere Werte als defines in meiner header definiert, welche in alle Dateien inkludiert werden.

    Nun habe ich eine Klasse voller Arrays, mit fester Länge, die ebenfalls über die defines festgelegt wird.
    Diese werden mit einer selbst geschriebenen init_array funktion beschrieben.
    Dies klappt auch ohne Probleme.

    Jetzt habe ich aber noch zwei Arrays, welche ich händig initialisieren muss, nämlich mit diesen define-Werten.
    Dies funktioniert aber nicht 😞

    Ich habe jetzt schon versucht dies in eine seperate Funktion auszulagern, was aber auch kein Erfolg brachte.

    Ich hoffe, ihr könnt mir helfen, denn ich seh den Wald vor lauter Bäumen nicht mehr und finde den bestimmt banalen Fehler nicht.

    Flag.h

    #include "main.h"
    
    class Flag {
    
    	int  	m_cntLenTime[FlgCnt];					
    	bool 	m_ExtActvBool[FlgCnt];				
    	int 	m_tMin_C[FlgCnt];						// min time of active bits for using
    	int	m_tFricExt_C[FlgCnt];					
    	int 	m_bitAryCtrlrFlgRaw[FlgCnt];		
    	int  	m_bitAryCtrlrFlgActv[FlgCnt];		
    	int  	m_bitAryCtrlrFlgCycRaw[FlgCnt];	
    	int  	m_bitAryCtrlrFlgCycRlv[FlgCnt];	
    
    	void 	init_array(int* bitAry, int* m_bitAry);	
    	void 	init_array(bool* bitAry, bool* m_bitAry);	
    	void 	init_flags();
    
    	public:
    		Flag(){} // standard constructor
    		Flag(int* cntLenTime, bool* ExtActvBool, int* bitAryCtrlrFlgRaw, int* bitAryCtrlrFlgActv, int* bitAryCtrlrFlgCycRaw, int* bitAryCtrlrFlgCycRlv) { 
    
    			init_array(cntLenTime, m_cntLenTime);
    			init_array(ExtActvBool, m_ExtActvBool);
    			init_array(bitAryCtrlrFlgRaw, m_bitAryCtrlrFlgRaw);
    			init_array(bitAryCtrlrFlgActv, m_bitAryCtrlrFlgActv);
    			init_array(bitAryCtrlrFlgCycRaw, m_bitAryCtrlrFlgCycRaw);
    			init_array(bitAryCtrlrFlgCycRlv, m_bitAryCtrlrFlgCycRlv);
    
    			init_flags();
    		 }
    
    		// Getters		
    		int* 	Get_cntLenTime()											{ return m_cntLenTime;}
    		int 	Get_cntLenTime(int value)								{ return m_cntLenTime[value];}
    
    		bool* Get_ExtActvBool()											{ return m_ExtActvBool; }		
    		bool 	Get_ExtActvBool(int value)								{ return m_ExtActvBool[value];}
    
    		int	Get_tMin_C(int value)									{ return m_tMin_C[value];}
    
    		int	Get_tFricExt_C(int value)								{ return m_tFricExt_C[value];}
    
    		int* 	Get_bitAryCtrlrFlgRaw()									{ return m_bitAryCtrlrFlgRaw;}
    		int 	Get_bitAryCtrlrFlgRaw(int value)						{ return m_bitAryCtrlrFlgRaw[value];}
    
    		int* 	Get_bitAryCtrlrFlgActv()								{ return m_bitAryCtrlrFlgActv;}
    		int 	Get_bitAryCtrlrFlgActv(int value)					{ return m_bitAryCtrlrFlgActv[value];}
    
    		int* 	Get_bitAryCtrlrFlgCycRaw()								{ return m_bitAryCtrlrFlgCycRaw;}
    		int 	Get_bitAryCtrlrFlgCycRaw(int value)					{ return m_bitAryCtrlrFlgCycRaw[value];}
    
    		int* 	Get_bitAryCtrlrFlgCycRlv()								{ return m_bitAryCtrlrFlgCycRlv;}
    		int 	Get_bitAryCtrlrFlgCycRlv(int value)					{ return m_bitAryCtrlrFlgCycRlv[value];}
    
    		// Setters
    		void 	Set_cntLenTime(int data, int value)					{ m_cntLenTime[value] = data;}
    		void 	Set_ExtActvBool(bool data, int value)				{ m_ExtActvBool[value] = data;}
    		void 	Set_bitAryCtrlrFlgRaw(int data, int value)		{ m_bitAryCtrlrFlgRaw[value] = data;}
    		void 	Set_bitAryCtrlrFlgActv(int data, int value)		{ m_bitAryCtrlrFlgActv[value] = data;}
    		void 	Set_bitAryCtrlrFlgCycRaw(int data, int value)	{ m_bitAryCtrlrFlgCycRaw[value] = data;}
    		void 	Set_bitAryCtrlrFlgCycRlv(int data, int value)	{ m_bitAryCtrlrFlgCycRlv[value] = data;}					
    };
    

    Flag.cpp

    /* includes headers */
    #include "main.h"
    
    using namespace std;
    
    /* ----- Functions ----- */
    
    void Flag::init_array(int* bitAry, int* m_bitAry){
    
    	for ( int i=0; i < FlgCnt; i++ ){		
    		m_bitAry[i] = bitAry[i];		
    	}	
    }
    
    void Flag::init_array(bool* bitAry, bool* m_bitAry){
    
    	for ( int i=0; i < FlgCnt; i++ ){		
    		m_bitAry[i] = bitAry[i];		
    	}	
    }
    
    void Flag::init_flags(){
    
    			m_tMin_C[BITPOS_FDR] = tMinFDR_C;
    			m_tMin_C[BITPOS_ABS] = tMinABS_C;
    			m_tMin_C[BITPOS_TCS] = tMinTCS_C;
    			m_tMin_C[BITPOS_MSR] = tMinMSR_C;
    
    			m_tFricExt_C[BITPOS_FDR] = tFricDetFDR_C;
    			m_tFricExt_C[BITPOS_ABS] = tFricDetABS_C;
    			m_tFricExt_C[BITPOS_TCS] = tFricDetTCS_C;
    			m_tFricExt_C[BITPOS_MSR] = tFricDetMSR_C;
    }
    

    main.h

    #define BITPOS_FDR 0			
    #define BITPOS_ABS 1
    #define BITPOS_TCS 2		
    #define BITPOS_MSR 3		
    #define tMinFDR_C 400			
    #define tMinABS_C 0
    #define tMinTCS_C 0
    #define tMinMSR_C 0
    #define tFricDetFDR_C 600	
    #define tFricDetABS_C 600
    #define tFricDetTCS_C 600
    #define tFricDetMSR_C 600
    #define FlgCnt 4				
    
    #include <iostream>
    #include "Flag.h"
    

    main.cpp

    int main()
    {
    	Flag flag;
    
    	cout << "Position BITPOS FDR: " << BITPOS_FDR << endl;
    	cout << "Position BITPOS ABS: " << BITPOS_ABS << endl;
    	cout << "Position BITPOS TCS: " << BITPOS_TCS << endl;
    	cout << "Position BITPOS MSR: " << BITPOS_MSR << endl;
    	cout << "tFricExt FDR als define: " << 	tFricDetFDR_C << endl;
    	cout << "tFricExt ABS als define: " << 	tFricDetABS_C << endl;
    	cout << "tFricExt TCS als define: " << 	tFricDetTCS_C << endl;
    	cout << "tFricExt MSR als define: " << 	tFricDetMSR_C << endl;
    	cout << "tFricExt FDR gespeichert in Klasse: " << flag.Get_tFricExt_C(0) << endl;
    	cout << "tFricExt ABS gespeichert in Klasse: " << flag.Get_tFricExt_C(1) << endl;
    	cout << "tFricExt TCS gespeichert in Klasse: " << flag.Get_tFricExt_C(2) << endl;
    	cout << "tFricExt MSR gespeichert in Klasse: " << flag.Get_tFricExt_C(3) << endl;
    	cout << "tMin FDR gespeichert in Klasse: " << flag.Get_tMin_C(0) << endl;
    	cout << "tMin ABS gespeichert in Klasse: " << flag.Get_tMin_C(1) << endl;
    	cout << "tMin TCS gespeichert in Klasse: " << flag.Get_tMin_C(2) << endl;
    	cout << "tMin MSR gespeichert in Klasse: " << flag.Get_tMin_C(3) << endl;
    
        return 0;
    }
    

    Ausgabe:

    Position BITPOS FDR: 0
    Position BITPOS ABS: 1
    Position BITPOS TCS: 2
    Position BITPOS MSR: 3
    tFricExt FDR als define: 600
    tFricExt ABS als define: 600
    tFricExt TCS als define: 600
    tFricExt MSR als define: 600
    tFricExt FDR gespeichert in Klasse: 0
    tFricExt ABS gespeichert in Klasse: 0
    tFricExt TCS gespeichert in Klasse: 0
    tFricExt MSR gespeichert in Klasse: 0
    tMin FDR gespeichert in Klasse: 0
    tMin ABS gespeichert in Klasse: 0
    tMin TCS gespeichert in Klasse: 0
    tMin MSR gespeichert in Klasse: 0
    


  • Es hülfe, wenn Du init_flags() auch im Standardkonstruktor aufriefest.

    Das ist recht viel Code für einen blöden Fehler, den Du gut selber hättest finden können, wenn Du den Source eingedampft hättest.
    Für die Zukunft: Wie man Probleme nachstellbar und nachvollziehbar macht.



  • Hallo,

    danke für den Tipp, das hat geholfen 🙂

    Vielen Dank


Log in to reply