Destruction d'objet automatique

Bonjour,

Je travaille sur un programme qui établi des liaisons a l'aide des sockets .
Chaque liaison est "gérée" par une classe , dans le main j'ai crée une boucle infinie je souhaite garder les connexions actives mais le traitement fonctionne une fois et a la fin de la première boucle du main le programme appelle les destructeurs de tous mes objets alors que je souhaite les garder.
Quelqu'un saurait me dire comment empecher leur destructions svp?

Merci d'avance.

Tu déclares tes objets à l'intérieur de ta boucle ? Si oui, il est normal qu'à chaque itération ils soient détruits et que de nouveaux soient créés. Bouge les en dehors de la boucle pour augmenter leur durée de vie. Si non, il faudrait poster un bout de code pour qu'on voit ce qui se passe.

réponse

J'ai opté pour une destruction et une construction de chaque objet a chaque passage de boucle .La connexion est donc perdue et recrée a chaque fois ....
mais j'ai un problème avec le chaque fois... le premier passage de boucle fonctionne parfaitement mais le deuxième tombe en erreur le premier dialogue s effectue bien et le second me dit que le port cible est occupé avec GetLastError() alors que le programme serveur est bien en écoute comme au premier passage..

Hello NoX_cpp,

Je pense qu'il faut que tu nous montre un peu de code, sinon c'est difficile pour nous de t'aider.

Carl

voici la classe qui "pose problème"

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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
using namespace std;
 
 
class client_s
{
private :
 
 
 
       char *tab;
       int gPort;
       SOCKET Socket_c;
       SOCKADDR_IN Socket_addr;
       WSADATA wsaData;
       int Connect;
       int Longueur;    
	   char *buffer;
 
 
 
public :
    client_s();
	~client_s();
	void connex (void);
    char * recup (void); 
	char * dial (char[20]);
 
};
 
void client_s::connex(void)
{
 
       //Port de connection
       gPort=30000;
 
       //Initialisation de la Socket_c 
 
       if(WSAStartup(MAKEWORD(2,0),&wsaData) != 0)
       {
            cout<<"Erreur initialisation Socket_c\n";
        }
	   else cout<<"Socket_c intialisee"<<endl;
 
		//Creation de la Socket_c
 
       Socket_c = socket(AF_INET,SOCK_STREAM,0);//Creation de la socket
       if(Socket_c == INVALID_SOCKET)
       {  
            cout<<"Erreur creation Socket_c "<<GetLastError()<<endl;
			system("pause");
        }
	   else cout<<"Socket_c parametree pour le TCP/IP"<<endl;
 
       //Parametrage de la Socket_c 
 
       memset(&Socket_addr,0, sizeof(Socket_addr));
       Socket_addr.sin_family = AF_INET;        //Parametrage de la socket
       Socket_addr.sin_port = htons(gPort);
       Socket_addr.sin_addr.s_addr = inet_addr("**********");
 
	   //Connection au serveur
 
       Connect = connect(Socket_c,(SOCKADDR *)&Socket_addr,sizeof(SOCKADDR_IN));
 
       if(Connect != 0)
       {
             cout<<"Erreur de connexion "<<GetLastError()<<endl;
			 return;
			 system("pause");
        }
	   else cout<<"Connection serveur OK"<<endl;
 
 
       return;
}
 
 
 
 
char * client_s::recup(void)
{
	return tab;
}
char* client_s::dial(char cod_pro[20])
{
 
	    char *ret=new char[];
		char *rep=ret;
 
	   cout<<" contenu d envoi :"<<cod_pro<<endl;
 
       Longueur=0;
 
       Longueur=send(Socket_c,cod_pro,strlen(cod_pro),0);//Envoi du code produit au serveur
	        if(Longueur == SOCKET_ERROR)
       {
            cout<<"Erreur d'envoi"<<endl;
       }
	   else {cout<<"Donnees envoyees"<<endl;}	
 
	   Longueur=0;
 
 
	  Longueur=recv(Socket_c,ret,49,0);//reception des Donnees techniques produit
	     if(Longueur ==-1)
		 {
			 cout<<"erreur de reception"<<endl;}
		 else cout<<"donnees recues"<<endl;
		 cout<<"Contenu de ret :"<<ret<<endl;
		 ret=NULL;
	WSACleanup();
	     return rep;
 
}
 
client_s::client_s()
{}
client_s::~client_s()
{}

et dans le main :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
char * dialoguebdd (client_s * pointeur_client_s,char dial_clt[20])
{
 
	/*if(semaphore==0)
	{*/
	 cout<<"Tentative de connexion Socket unix :"<<endl;
	pointeur_client_s->connex();
	/*semaphore ++;
	}*/
    rec=pointeur_client_s->dial(dial_clt);
 
	cout<<"reponse du serveur :"<<rec<<endl;
    //system("cls");//clear screen
 
	return rec;
}

enfin coté serveur :

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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
 
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#include <sqlca.h>
 
 
EXEC SQL BEGIN DECLARE SECTION;
VARCHAR username[20];
VARCHAR resultat[50];
VARCHAR table1 [30];
VARCHAR listeny [100];
int status;
int msg_length;
char *buf;
char resul[500];
char retval[200];
EXEC SQL END DECLARE SECTION;
 
   int sockfd, newsockfd;
 
main()
{
     int rcv,snd;
     char  tampon[20];
     char * result;
     char * req(char[20]);
     char * tab_cli=NULL;
     void connex (void);
 
 
     strcpy(username.arr ,"***********************");
     username.len=strlen(username.arr);
     EXEC SQL CONNECT :username;                                                     printf("Connexion Maqsycom\n");
 
 
 
 char welcome[25]="Bienvenue sur ***********";
 
      connex();
 
      close(sockfd);
 
 
      for(;;)
      {
 
 snd= send(newsockfd,welcome,sizeof(welcome),0);
 if(snd>0)
 {
 printf("donnes envoyees \n");
 }
 else printf ("erreur envoi de donnees \n");
 sleep(10);
 
 
 rcv= recv(newsockfd,tampon,7,0);
 
     if(rcv>0)
     {
     printf("donnee recues\n");
     }
     else printf ("erreur reception des donnees\n");
    printf("premier send du client : %s\n" ,tampon);
 
 
    result=req(tampon);
 
 
  /*  send(newsockfd,result,strlen(result),0);
 
    recv(newsockfd,table1.arr,sizeof(table1.arr),0);
    printf("2e send du client : : %s\n",table1.arr);*/
 
}
 
}
 
 
 
 
char* req (char tampon[20])
{
 
 
  int res;
 
       strcpy(listeny.arr,tampon);
       listeny.len=strlen(listeny.arr);
 
          printf("transmission du tableau : %s\n",listeny.arr);
 
EXEC SQL SELECT lib_pro into :resultat from pro  where cod_pro=:listeny;
 
 
  strcat(resultat.arr,'\0');
  printf("varchar resultat :  %s\n ",resultat.arr);
  printf("\n");
 
  strcpy(resul,resultat.arr);
 
buf=resul;
printf("transfert de varchar dans buf : %s\n",buf);
 
return buf;
 
}
 
void connex (void)
 
      {
 
 
 
 
  int   clilen ;
  struct sockaddr_in cli_addr, serv_addr;
 
  if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    printf("Erreur creation socket");
 
  printf("socket initialisee\n");
 
  bzero((char *) &serv_addr, sizeof(serv_addr));
  serv_addr.sin_family   = AF_INET;
  serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
  serv_addr.sin_port   = htons(30000);
 
  if (bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0)
     printf("Le serveur ne peut pas se lier");
 
     else  printf("Le serveur a etabli une liaison\n");
 
   listen(sockfd, 1);
 
   clilen = sizeof(cli_addr);
   newsockfd = accept(sockfd, (struct sockaddr *) &cli_addr,&clilen);
   if (newsockfd < 0)
   printf("Erreur de connexion");
 
 
}

Je n'ai pas l'habitude de ce type de code, mais il me semble que tu ne fermes pas la socket. Ton port 30000 resterait donc ouvert à la fin de la première itération, ce qui expliquerait le problème lors de la seconde.

Pour info, en C++ on a l'habitude de gérer les ressources à l'aide du destructeur de l'objet qui est responsable de la ressource. Ici, la ressource c'est Socket_c. Ce que je te recommanderais, c'est d'ouvrir la connexion dans le constructeur de l'objet et la fermer dans le destructeur.

Bon courage,

Carl

en fin de boucle dans le main je détruit complètement l'objet :

Code:

pointeur_client_s->~client_s();

Il faudrait que je ferme avant ca la socket "sock" à l'aide de Close() ou shutdown() ?

Ce n'est pas une bonne façon de détruire un objet, ça...

C'est à réserver à des cas très exceptionnels, comme certains conteneurs...

Je ne connais que ca , l'appel au destructeur.Quelles sont donc les autres méthodes ?

Le delete d'un objet sur le tas, ou le delete[] d'un tableau d'objets sur le tas.

Normalement, il ne faut jamais faire d'appel explicite au destructeur d'un objet en mémoire autre que le tas, car alors le destructeur serait appelé deux fois: Une fois explicitement, puis une fois implicitement...

delete[nomdemonobjet] donc?

(merci beaucoup de votre aide)

:faq: --> Doit-on détruire explicitement les objets locaux ?