Passer du c++ en C.

Version imprimable

Passer du c++ en C.

Bonjour,
j'ai trouvé un programme sur internet qui m'intéresse et je voudrais letraduire en c. Es-ce possible?

le voici:

CIC.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
// 
// Copyright(c) 1993-1996 Tony Kirke
// author="Tony Kirke" *
/*
 * SPUC - Signal processing using C++ - A DSP library
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#ifndef CIC
#define CIC
namespace SPUC {
/*! 
  \addtogroup fir FIR filters
*/
 
/*!   \brief   class for CIC digital filter
  \ingroup fir interpolation
*/
//!
//!  Implementation for cascaded integrator comb filters
//!  This implementation provides for both decimation and
//!  interpolation filtering. Registers are signed long and
//!  the default number of stages is 3.
//! \image html cic.gif
//! \image latex cic.eps
class cic
{
 protected:
  signed long* nacc; //! Accumulators
  signed long* diff; //! Differentiators
  signed long* prev; //! Previous values
  char stages; //! Number of stages
 public:                         
  //! Constructor
  cic(char n=3);
  //! Reset
  void reset() { 	
	for (int i=0;i<stages;i++) nacc[i] = diff[i] = prev[i] = 0;
  }
  //! For CIC interpolation, non-zero dump implies new input
  signed long interpolate(signed long in=0, signed char dump=0);
  //! For CIC decimation, non-zero dump implies output required
  signed long decimate(signed long in, signed char dump);
  //! To change the number of stages dynamically
  void num_stages(char n);
};
} // namespace SPUC 
#endif

cic.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
// 
// Copyright(c) 1993-1996 Tony Kirke
// author="Tony Kirke" *
/*
 * SPUC - Signal processing using C++ - A DSP library
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
// See cic.h for description
#include <cic.h>
namespace SPUC {
cic::cic(char n) : stages(n)
{
	int i;
	nacc = new signed long[n];  
	diff = new signed long[n]; 
	prev = new signed long[n]; 
	for (i=0;i<stages;i++) nacc[i] = diff[i] = prev[i] = 0;
}
void cic::num_stages(char n)
{
	int i;
	stages = n; 
	delete nacc;
	delete diff;
	delete prev; 
	nacc = new signed long[n];  
	diff = new signed long[n]; 
	prev = new signed long[n]; 
	for (i=0;i<stages;i++) nacc[i] = diff[i] = prev[i] = 0;
}
signed long cic::interpolate(signed long in, signed char dump)
{
	char i;
	if (dump) {
		diff[0] = in - prev[0];
		prev[0] = in;
		for (i=1;i<stages;i++) {
			diff[i] = diff[i-1] - prev[i];
			prev[i] = diff[i-1];
		}
		nacc[0] += diff[stages-1];
	}  
	for (i=0;i<(stages-1);i++) nacc[i+1] += nacc[i];
	return(nacc[stages-1]);
} 
signed long cic::decimate(signed long in, signed char dump)
{
	char i;
	nacc[0] += in;
	for (i=0;i<(stages-1);i++) nacc[i+1] += nacc[i];
	if (dump) {
		diff[0] = nacc[stages-1] - prev[0];
		prev[0] = nacc[stages-1];
		for (i=1;i<stages;i++) {
			diff[i] = diff[i-1] - prev[i];
			prev[i] = diff[i-1];
		}
	}
	return(diff[stages-1]);
}
 
 
} // namespace SPUC

Merci de votre aide.

12/04/2007, 15h51
Franck.H

A priori oui, rien de bien insurmontable à ce que je vois ;)

Une structure qui reprend les données (variables) de la classe et des fonctions prennant en argument cette structure pour pouvoir travailler sur les données ... pas très dur en soit ! Il n'y a pas spécialement de concepts objets utilisés ici sauf bien sûr le fait que c'est une classe mais sans plus !

Citation:

Envoyé par sandball22

Bonjour,
j'ai trouvé un programme sur internet qui m'intéresse et je voudrais letraduire en c. Es-ce possible?

Oui.

Je te fais l'entête (il n'y a pas d'héritage donc ça va très bien) :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 #ifndef CIC_H #define CIC_H typedef struct { signed long* nacc; //! Accumulators signed long* diff; //! Differentiators signed long* prev; //! Previous values char stages; //! Number of stages } Cic; int cicInit(Cic *, char n); void cicReset(Cic *); signed long cicInterpolate(Cic*, signed long, signed char); signed long cicDecimate(Cic*, signed long, signed char); void cicNum_stages(Cic*, char n); void cicDelete(Cic*); #endif
Puis, il te suffira de changer les new en malloc pour les char et les long.

12/04/2007, 15h59
sandball22

Merci. Par contre j'ai pa très bien compris dans le code que je vous ai donné la fonction correspondant à decilate si quelquun pouvait m'aider? Merci

Petite correction:

Code:

1
2
3
4
5
6
7
typedef struct 
{
  signed long* nacc; //! Accumulators
  signed long* diff; //! Differentiators
  signed long* prev; //! Previous values
  char stages; //! Number of stages
} Cic;

Le mot clé protected n'existe pas en C ;)

12/04/2007, 16h04
millie

Citation:

Envoyé par Franck.H

Petite correction:

Le mot clé protected n'existe pas en C ;)

:oops: mauvais copié collé. J'ai corrigé ;) :merci:
12/04/2007, 16h20
sandball22

Merci. Par contre j'ai pa très bien compris dans le code que je vous ai donné la fonction correspondant à decimate si quelquun pouvait m'aider? Merci

J'ai un problème au niveau de ma structure.
voila l'erreur:
error: request for member `stages' in something not a structure or union

voici le code .h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
#ifndef _DVBT_CIC_H
#define _DVBT_CIC_H
 
/* ======== */
/* INCLUDES */
/* ======== */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <time.h>
#include <sys/timeb.h>
#include <unistd.h>
 
/* =============== */
/* DEFINES / ENUMS */
/* =============== */
 
/* ========== */
/* STRUCTURES */
/* ========== */
typedef struct {
	int i;
  signed long* nacc;        /*Accumulateur*/ 
  signed long* diff;        /*Differentiateur*/ 
  signed long* prev;        /*Valeurs précédentes*/
  int stages;               /*Nombre d'étages*/
 
  /*!<
                \~english       .
                \~french        .
        */
} DVBTCic;
 
 
 
/* ====================== */
/* PROTOTYPES / FUNCTIONS */
/* ====================== */
DVBTCic *CreateDVBTCic();
void FreeDVBTCic(DVBTCic *DC);
void UseDVBTCic(DVBTCic *DC);
void ResetDVBTCic(DVBTCic *DC);
 
int          CicInit(DVBTCic *DC, int n);
signed long  CicDecimate(DVBTCic *DC, signed long in , signed char dump);
void         CicNum_stages(DVBTCic *DC, int n);
 
 
 
 
#endif

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
 
#include "dvbt_cic_v01.h"
 
 
DVBTCic *CreateDVBTCic() {
 
	DVBTCic *DC;
 
	/* Memory allocation for structure DVBTCic. */
	DC = (DVBTCic *)calloc(1, sizeof(DVBTCic));
	if (!DC) {
		printf("\nERROR !\tCreateDVBTCic : unable to allocate memory for DVBTCic structure.\n\n");
		exit(EXIT_FAILURE);
	}
 
	return (DC);
}
 
 
void FreeDVBTCic(DVBTCic *DC) {
 
	/* Test structure existence. */
	if (!DC) {
		printf("\nWARNING !\tFreeDVBTCic : structure DVBTCic does not exist.\n\n");
		return;
	}
 
	/* Memory release. */
	free(DC);
 
	return;
}
 
 
void UseDVBTCic(DVBTCic *DC) 
{
   int nombre_etages;
 
 
   printf("\nNombre d'étages du CIC :");
   scanf("%d",&nombre_etages);	
 
 
 
	CicNum_stages(DC, nombre_etages);
 
	return;
}
 
 
int CicInit(DVBTCic *DC, int n)
{
   int a;
 
return(a);
}
 
 
 
 
 
 
void  CicNum_stages(DVBTCic *DC, int n)
{   
    int i;
	DC.stages = n; 
 
	free(DC.nacc);
	free(DC.diff);
	free(DC.prev); 
 
    DC.nacc=(signed long*)malloc(sizeof(int)*(n));
    DC.diff=(signed long*)malloc(sizeof(int)*(n));
    DC.prev=(signed long*)malloc(sizeof(int)*(n));
 
 
	for (i=0;i<DC.stages;i++)  DC.nacc[i] =  DC.diff[i] =  DC.prev[i] = 0;
 
	return;
}
 
 
signed long  CicDecimate(DVBTCic *DC, signed long in, signed char dump)
{
    signed long a;
    return(a);
 
}
 
void ResetDVBTCic(DVBTCic *DC) {
 
 
 
	return;
}

12/04/2007, 17h14
fearyourself

C'est normal dans ta dernière fonction, c'est des -> et non des '.' pour accéder aux champs de ta structure vu que tu as un pointeur...

Jc
12/04/2007, 17h44
sandball22

Ok merci. j'ai résolu ce problème.
J'arrive pas trop à comprendre le code pour Decimate. Quelqu'un peut-il m'aider?
Merci.
13/04/2007, 09h36
fearyourself
Citation:

Envoyé par sandball22

Personne ne peut m'aider?

Si tu parles de ceci :
Code:

1 2 3 4 5 6 signed long CicDecimate(DVBTCic *DC, signed long in, signed char dump) { signed long a; return(a); }
C'est un comportement indéfini...
Jc

Non , je parle de ceci::

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
signed long cic::decimate(signed long in, signed char dump)
{
	char i;
	nacc[0] += in;
	for (i=0;i<(stages-1);i++) nacc[i+1] += nacc[i];
	if (dump) {
		diff[0] = nacc[stages-1] - prev[0];
		prev[0] = nacc[stages-1];
		for (i=1;i<stages;i++) {
			diff[i] = diff[i-1] - prev[i];
			prev[i] = diff[i-1];
		}
	}
	return(diff[stages-1]);
}

13/04/2007, 10h08
millie

Tu cherches à traduire un code C++, mais tu ne sais pas à quoi ça sert ?