pb avec windows.h sous linux

Réponse acceptée !
J'ai tout de suite titlté en voyant le titre et je ne suis pas deçu

windows.h comme son nom l'indique est un bibliothèque windows uniquement. Sous linux, tu n'en a pas besoin et de toute facon, comme tu le dis si bien elle n'existe pas. Tu la vire de ton code et tu regarde par la suite les fonction que ton compilo te dit qu'elle ne sont pas définis. A ce moment la tu fais un "man lafonction" et tu veras quelle fichier d'en-tete inclure. En espérant que tu as codé en C++ !

---

TuRn3r

Réponse acceptée !
Je n'est pas de fonction qui ne sont pas definies...Mon programme se compile correctement mais quand je l'execute il ne se passe rien...

merci pour vos reponse

Réponse acceptée !
Poste ton code, s'il y a pas 30000 lignes pour voir !

Réponse acceptée !
Le voici :

#include <stdio.h>
#include <iostream>
#include <mysql/mysql.h>
#include <stdlib.h>
#include <string.h>
#include <cstring>
#include <fstream>
#include <string>
#include <time.h>
using namespace std;

//lire le fichier et extraire les infos, a ne pas toucher!!
char** split(char* chaine,const char* delim,int vide)
{
    char** tab=NULL;              //tableau de chaine, tableau resultat
       char *ptr;                     //pointeur sur une partie de
       int sizeStr;                   //taille de la chaine à recupérer
       int sizeTab=0;                 //taille du tableau de chaine
       char* largestring;             //chaine à traiter
       int sizeDelim=strlen(delim);   //taille du delimiteur
       largestring = chaine;          //comme ca on ne modifie pas le pointeur d'origine
       while( (ptr=strstr(largestring, delim))!=NULL )
       {
          sizeStr=ptr-largestring;

          //si la chaine trouvé n'est pas vide ou si on accepte les chaine vide
          if(vide==1 || sizeStr!=0)
          {
              //on alloue une case en plus au tableau de chaines
              sizeTab++;
              tab= (char**) realloc(tab,sizeof(char*)*sizeTab);

              //on alloue la chaine du tableau
              tab[sizeTab-1]=(char*) malloc( sizeof(char)*(sizeStr+1) );
              strncpy(tab[sizeTab-1],largestring,sizeStr);
              tab[sizeTab-1][sizeStr]='\0';
          }

          //on decale le pointeur largestring  pour continuer la boucle apres le premier elément traiter
          ptr=ptr+sizeDelim;
          largestring=ptr;
   }

   //si la chaine n'est pas vide, on recupere le dernier "morceau"
       if(strlen(largestring)!=0)
       {
          sizeStr=strlen(largestring);
          sizeTab++;
          tab= (char**) realloc(tab,sizeof(char*)*sizeTab);
          tab[sizeTab-1]=(char*) malloc( sizeof(char)*(sizeStr+1) );
          strncpy(tab[sizeTab-1],largestring,sizeStr);
          tab[sizeTab-1][sizeStr]='\0';
       }
       else if(vide==1)
       { //si on fini sur un delimiteur et si on accepte les mots vides,on ajoute un mot vide
          sizeTab++;
          tab= (char**) realloc(tab,sizeof(char*)*sizeTab);
          tab[sizeTab-1]=(char*) malloc( sizeof(char)*1 );
          tab[sizeTab-1][0]='\0';
       }

   //on ajoute une case à null pour finir le tableau
   sizeTab++;
   tab= (char**) realloc(tab,sizeof(char*)*sizeTab);
   tab[sizeTab-1]=NULL;

   return tab;
}

int main(void)
{
/*
  #################################################
  ###                                           ###
  ###       définir toutes les variables        ###
  ###                                           ###
  #################################################
*/
  int i,b,w;//,x,y,a,z;
  int r=0;
  int v,n;
  //int m;
  string u;
  string line;
  char s[100];   //pour la chaine de caractère String -> char
  char c[100];
  char d[100];    //pour le nommage du fichier
  char e[100];    //juste le nom de la porte
  char f[100];
  char g[100];
  char** tab;
  char *host;
  char *user;
  char *pass;
  char *db;
  char *table;
  int System;
  MYSQL mysql;
  mysql_init(&mysql);

/*
  #################################################
  ###                                           ###
  ###       Prendre les informations            ###
  ###       dans le fichier conf.txt            ###
  ###                                           ###
  #################################################
*/

ifstream txt ("conf.txt");
int Comptage=0;
int compteligne=1;
       while (getline(txt,u))
       {
       Comptage++;
       }
txt.close();
       ifstream texte("conf.txt");
       while (getline(texte,line))
       {
       char *s=new char[100];
       strncpy(s,line.c_str(),100);
       if (compteligne==4){
           host=s;
       }
       if (compteligne==6){
           user=s;
       }
       if (compteligne==8){
            pass=s;
       }
       if (compteligne==10){
           db=s;
       }
       if (compteligne==12){
           table=s;
       }
       compteligne++;
       }
texte.close();
/*

  #################################################
  ###                                           ###
  ###       définir les fichiers commme         ###
  ###     des variables pour les utiliser       ###
  ###                                           ###
  #################################################
*/
   sprintf(d,"fichier_dump.sql");
/*
  #################################################
  ###                                           ###
  ###           ouvir le fichier                ###
  ###                                           ###
  #################################################
*/
  FILE *fp = fopen (d,"r");
/*
  #################################################
  ###                                           ###
  ###       si le fichier n'existe pas          ###
  ###             ne rien faire                 ###
  ###                                           ###
  #################################################
*/
if (fp == NULL)
{
    printf(" ");
}

else
{
      int countlines = 1;                       //permet de savoir la ligne à traiter
      int Count = 0;                            //défini le nombre totale de lignes dans le fichier

      ifstream file(d);                        //lire le fichier concerné
/*
  #################################################
  ###                                           ###
  ###       on va compter le nombre total       ###
  ###             de lignes                     ###
  ###                                           ###
  #################################################
*/
  while (getline(file, u))
  {
    Count++;
  }
file.close();
  ifstream text(d);
/*
  #################################################
  ###                                           ###
  ###         on va lire le fichier             ###
  ###           lignes par lignes               ###
  ###                                           ###
  #################################################
*/
  while(getline(text,line))
  {
        /*size_t size  = str.size() + 1;            //je converti le string en char
        char *s = new char[ 50 ];
        strncpy( s, line.c_str(), 50 );
        tab=split(s," ",0);                       //je découpe la chaine par rapport aux espaces ("a changer si tu coupe en fonction d'autre chose ;) )
        for(i=0;tab[i]!=NULL;i++)*/
       
        using namespace std;

    string str = "une chaîne de caractères";
    // créer le buffer pour copier la chaîne
    size_t size = str.size() + 1;
    char * buffer = new char[ size ];
    // copier la chaîne
    strncpy( buffer, str.c_str(), size );
    // utiliser le buffer
    cout << buffer << '\n'; // "une chaîne de caractères"
    // libérer la mémoire
    delete [] buffer;
   {
        int j= 0;
        while(tab[i][j] != '\0')
        {
             j++;
        }
/*
  #################################################
  ###                                           ###
  ###       on va sortir les informations       ###
  ###                des lignes                 ###
  ###                                           ###
  #################################################
*/

if (countlines>=3 && countlines<=Count && i==0)
{
    sprintf(c,"insert into %s values(' ','%s','%c%c',",table,e,tab[i][0],tab[i][1]);
    sprintf(f,"%s",c);
}

if (countlines>=3 && countlines<=Count && i==0)
{
    b=0;
    n=3;
    while (n<10 && b==0)
    {
        if (tab[i][n]!='0'){b=10-n;}n++;
    }
    v=10-b;
    while (v<10)
    {
        sprintf(c,"%c",tab[i][v]);
        w=v+(b-10);
        sprintf(f,"%s%s",f,c);
        v++;
    }
}
if (countlines>=3 && countlines<=Count && i==2)
{
    sprintf(c,",'%c%c/%c%c/20%c%c'," ,tab[i][0],tab[i][1],tab[i][2],tab[i][3],tab[i][4],tab[i][5]);
    sprintf(f,"%s%s",f,c);
}
if (countlines>=3 && countlines<=Count && i==3)
{
    sprintf(c,"'%c%ch%c%c');\n",tab[i][0],tab[i][1],tab[i][2],tab[i][3]);
    sprintf(f,"%s%s",f,c);



/*
  #################################################
  ###                                           ###
  ###      connection a la base de donnée       ###
  ###                                           ###
  #################################################

*/
//création d'un fichier log si il y a une erreur de connection ou d'insertion...pratique ^^
   MYSQL *sock;
   MYSQL_RES *res;
   MYSQL_ROW row;
   sock = mysql_init(0);
   if (sock);
   else
   {
        cout << "sock handle failed!" << endl;
   }
   if (!mysql_real_connect(&mysql,"localhost","root","","projet",0,NULL,0));
   else
   {
        std::ofstream file( "log.txt", std::ios_base::app );
        time_t t;
        time(&t);
        sprintf(c,"connection échouée à %s \n\n",ctime(&t));
        file<<c;
        r=1;
   }

  if(mysql_query(sock,f))
  {
       std::ofstream file( "log.txt", std::ios_base::app );
       time_t t;
       time(&t);
       sprintf(c,"insertion échouée à %s ligne %d\n\n",ctime(&t),countlines);
       file<<c;
       r=1;
  }
      
  if(r==1)
  {
           exit(1);
  }
/*
  #################################################
  ###                                           ###
  ###     déconnection à la base de donnée      ###
  ###                                           ###
  #################################################
*/
   mysql_close(sock);
   }
/*
  #################################################
  ###                                           ###
  ###       désallocation des chaines           ###
  ###                                           ###
  #################################################
*/
   free(tab[i]);
   }  //fin du for(i=0;tab[i]!=NULL;i++)
   free(tab);
   ++countlines;
   }//fin du while(getline(text,line))
   text.close();
   printf("Now closing it...\n");
   fclose(fp);
}//fin du else;
//system("pause");
exit(1);
}//fin du int()

Réponse acceptée !
Euh, oui, mais bon, c'est à quel endroit que ton prog plante !

Réponse acceptée !
En faite je souhaite faire une mise a jour de ma base de donnée à l'aide d'un fichier texte que j'ai exporter...
Je travail en c++ sous linux avec eclipse.

Voici le fichier texte:
[code]
DROP TABLE IF EXISTS `PrixSouhaite`;
CREATE TABLE `PrixSouhaite` (
  `CodeBarre` int(20) unsigned NOT NULL default '0',
  `Marque` varchar(30) NOT NULL,
  `Type` text NOT NULL,
  `Produit` varchar(50) NOT NULL,
  `PrixConseille` float unsigned NOT NULL default '0',
  PRIMARY KEY  (`CodeBarre`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

--
-- Dumping data for table `PrixSouhaite`
--


/*!40000 ALTER TABLE `PrixSouhaite` DISABLE KEYS */;
LOCK TABLES `PrixSouhaite` WRITE;
INSERT INTO `PrixSouhaite` VALUES (789541321,'tosh','eiei','toto',123),(4294967295,'hp','multimedia','PC2ouf',6000),(123456789,'sony','multi','play',150),(321654987,'lol','film','start',1500),(65489789,'sony','console','touch',200),(65413987,'lol','film','pitoucDormous',250),(123654897,'tosh','DVD','les schtroumphes',160),(789456123,'test','test','test',123),(15975348,'test1','test1','test1',1231),(89745613,'test2','test2','test2',12311),(47987123,'test5','test5','test5',198000000);
UNLOCK TABLES;
[/code]