Löschen von Array als Rückgabewert



  • Hallo.
    Ich sende mit meinem Programm Daten über RS232.
    Die Bytes werden in verschiedenen Kommandos versendet.
    Im Kommando 18 sende ich zwei Strings( TAG, Descriptor).
    Die beiden Strings werden mit der Funktion PackASCII() in packed ascii formatiert und in BYTE* TAG, BYTE* Descriptor geschrieben, und anschließend ins Array BYTE HARTCOMMAND_18.
    Mein Problem ist es das diese beiden Strings immer die gleichen Werte enthalten, obwohl ich ihnen unterschiedliche Werte zuweise.
    Wie kann ich das verhindern?
    Wie kann ich den Rückgabewert der Funktion PackASCII() wieder löschen bevor sie ein zweites mal ausgeführt wird?

    void TH200COM::LoadData2TH200
    {
    //COMMAND 18, Initialize TAG, Descriptor, Date
    	BYTE* TAG=PackASCII(MyApp->GetView()->GetVarTAG(), 8);
    	BYTE* Descriptor=PackASCII(MyApp->GetView()->GetVarDescriptor(), 12);
    	BYTE Day=(BYTE)MyApp->GetView()->iDay;
    	BYTE Month=(BYTE)MyApp->GetView()->iMonth;
    	BYTE Year=(BYTE)(MyApp->GetView()->iYear-1900);
    	BYTE HARTCOMMAND_018[35] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x82, 0xAA, Flags, DeviceId[0], DeviceId[1], DeviceId[2],
    		  0x12, 0x15, TAG[0], TAG[1], TAG[2], TAG[3], TAG[4], TAG[5], Descriptor[0], Descriptor[1], Descriptor[2], Descriptor[3],
    		  Descriptor[4], Descriptor[5], Descriptor[6], Descriptor[7], Descriptor[8], Descriptor[9], Descriptor[10], Descriptor[11], 
    		  Day, Month, Year, 0x00};
    	HARTCOMMAND_018[34] = BuildChecksum(HARTCOMMAND_018, 34);
    }
    
    /*This method convert ascii to packed ascii:
        1.converts the 4 received bytes from hex to binary format.
        2.the 4 received bytes(binary) are seperated in 3 parts, 
          remove bit 6 and bit 5
        3.converts back to hex format
    	  BinaryValue = ascii in binary format(4Bytes)
    	  Packed = Packed ascii in binary format(3Bytes)
    	  PackedASCII = return packed ascii in hex format*/
    BYTE* TH200COM::PackASCII(CString String, int StringLength)
    {	 
    	BYTE BinaryValue[32][8], Packed[24][8], PackedASCII[24];
    	int nValue[32];	
    
    	for(int i=String.GetLength(); i<StringLength; i++) String+="_"; 
    
    	for(int i=0; i<StringLength; i++)
    	{		
    	   nValue[i]=(int)String[i];
    	   if(nValue[i]>96){nValue[i]=nValue[i]-32;}
    	   else{nValue[i]=nValue[i];}
    
    	    if(nValue[i]>=128) {BinaryValue[i][7]=1; nValue[i]-=128;} else BinaryValue[i][7]=0;
    		if(nValue[i]>=64) {BinaryValue[i][6]=1; nValue[i]-=64;} else BinaryValue[i][6]=0;
    		if(nValue[i]>=32) {BinaryValue[i][5]=1; nValue[i]-=32;} else BinaryValue[i][5]=0;
    		if(nValue[i]>=16) {BinaryValue[i][4]=1; nValue[i]-=16;} else BinaryValue[i][4]=0;
    		if(nValue[i]>=8) {BinaryValue[i][3]=1; nValue[i]-=8;} else BinaryValue[i][3]=0;
    		if(nValue[i]>=4) {BinaryValue[i][2]=1; nValue[i]-=4;} else BinaryValue[i][2]=0;
    		if(nValue[i]>=2) {BinaryValue[i][1]=1; nValue[i]-=2;} else BinaryValue[i][1]=0;
    		if(nValue[i]>=1) {BinaryValue[i][0]=1; nValue[i]-=1;} else BinaryValue[i][0]=0;
    	}
    
    	int j=1, k=0, l=2, m=1, n=3;
    	for(int i=0; i<24; i=i+3)
    	{
    		Packed[i][0]=BinaryValue[i+j][4]; 
    		Packed[i][1]=BinaryValue[i+j][5];
    		Packed[i][2]=BinaryValue[i+k][0]; 
    		Packed[i][3]=BinaryValue[i+k][1]; 
    		Packed[i][4]=BinaryValue[i+k][2];
    		Packed[i][5]=BinaryValue[i+k][3];
    		Packed[i][6]=BinaryValue[i+k][4];
    		Packed[i][7]=BinaryValue[i+k][5];
    
    		Packed[i+1][0]=BinaryValue[i+l][2];
    		Packed[i+1][1]=BinaryValue[i+l][3];
    		Packed[i+1][2]=BinaryValue[i+l][4];
    		Packed[i+1][3]=BinaryValue[i+l][5];
    		Packed[i+1][4]=BinaryValue[i+m][0];
    		Packed[i+1][5]=BinaryValue[i+m][1];
    		Packed[i+1][6]=BinaryValue[i+m][2];
    		Packed[i+1][7]=BinaryValue[i+m][3];
    
    		Packed[i+2][0]=BinaryValue[i+n][0];
    		Packed[i+2][1]=BinaryValue[i+n][1];
    		Packed[i+2][2]=BinaryValue[i+n][2];
    		Packed[i+2][3]=BinaryValue[i+n][3];
    		Packed[i+2][4]=BinaryValue[i+n][4];
    		Packed[i+2][5]=BinaryValue[i+n][5];
    		Packed[i+2][6]=BinaryValue[i+l][0];
    		Packed[i+2][7]=BinaryValue[i+l][1];
    
    		j++; k++; l++; m++; n++;
    	}
    //conversion from binary to hex format
    	for(int i=0; i<24; i++)
    	{
    		int nValue[24];
    		nValue[i]=0;
    
    	if(Packed[i][0]==1) {nValue[i]+=1;} else {nValue[i]+=0;}
    	if(Packed[i][1]==1) {nValue[i]+=2;} else {nValue[i]+=0;}
    	if(Packed[i][2]==1) {nValue[i]+=4;} else {nValue[i]+=0;}
    	if(Packed[i][3]==1) {nValue[i]+=8;} else {nValue[i]+=0;}
    	if(Packed[i][4]==1) {nValue[i]+=16;} else {nValue[i]+=0;}
    	if(Packed[i][5]==1) {nValue[i]+=32;} else {nValue[i]+=0;}
    	if(Packed[i][6]==1) {nValue[i]+=64;} else {nValue[i]+=0;}
    	if(Packed[i][7]==1) {nValue[i]+=128;} else {nValue[i]+=0;}
    
    	PackedASCII[i]=(BYTE)nValue[i];
    	}
      return PackedASCII;
    }
    


  • Du hast ein lokales Array namens "PackedASCII", das bei jedem Funktionsaufruf neu überschrieben wird. Abgesehen davon, daß die Daten am Funktionsende wieder vernichtet werden (d.h. eigentlich stehen in dem Array nichtmal mehr gültige Daten) solltest du die Werte aus dem zurückgegebenen Array an anderer Stelle lagern, bevor du weitermachst.

    (Eine gute Idee wäre es, statt des nackten Arrays eine Array-Klasse zu verwenden - std::vector<BYTE>, std::string oder auch MFC-Container)



  • ich werde es erstmal noch ohne eine Array-Klasse versuchen. Wenn ich später noch genügend Zeit habe werde ich mich dann mal in MFC_Container einlesen.



  • So wie ich das vor hatte funktionierts leider nicht.
    Kann mal jemand etwas Code posten, mit dem funktionieren sollte?
    Danke



  • Möglichkeit 1 - nimm einen vector (mit anderen Containern klappt's analog:

    vector<BYTE> TH200COM::PackASCII(CString String, int StringLength)
    {
      ...//den eigentlichen Funktionsrumpf kannst du normal übernehmen
      return vector<BYTE>(PackedASCII,PackedASCII+24);
    }
    
    vector<BYTE> TAG=PackASCII(MyApp->GetView()->GetVarTAG(), 8);
    vector<BYTE> Descriptor=PackASCII(MyApp->GetView()->GetVarDescriptor(), 12);
    

    Möglichkeit 2 - lass dir vom Aufrufer Speicher bereitstellen:

    void TH200COM::PackASCII(CString String,int StringLength,BYTE* PackedASCII)
    {
      BYTE BinaryValue[32][8], Packed[24][8] /*fällt weg:, PackedASCII[24]*/;
      ...//Rest wie gehabt
      return;
    }
    
    BYTE TAG[24],Desprictor[24];
    PackASCII(MyApp->GetView()->GetVarTAG(),8,TAG);
    PackASCII(MyApp->GetView()->GetVarDescriptor(),12,Descriptor);
    

    Alternativ könntest du die Variable PackedASCII auch static deklarieren und nach jedem Funktionsaufruf in ein eigenes Array kopieren oder dynamisch per new Speicher anfordern (den muß dein Hauptprogramm freigeben, wenn er nicht mehr gebraucht wird).


Log in to reply