strings.h et envelopper cette macro avec une macro vérifier si

Question

Je déduis des résultats de recherche de Google que strings.h (de here) est pour les systèmes UNIX. Je voudrais envelopper la ligne suivante avec une vérification de la macro pour savoir si le système d'exploitation de l'hôte est Linux/UNIX. Il serait très apprécié d'entendre des suggestions à ce sujet. Merci d'avance.

#include <strings.h> 

Answer 1

Une option serait:

#ifndef _WIN32 
#include <strings.h> 
#endif 

Per MSDN, _WIN32 est "défini pour les applications Win32 et Win64 toujours défini."

Un compilateur ou une bibliothèque standard pour un système d'exploitation autre que Windows est, bien sûr, libre de définir _WIN32, mais ce serait [...] inhabituel.

Answer 2

strings.h ne contient que quelques fonctions, dont la plupart sont simplement des noms différents pour les fonctions qui sont dans la bibliothèque standard (comme bcmp() < ->memcmp()). Si votre code utilise ces fonctions, au lieu de lancer #ifdef s pourquoi ne pas simplement écrire votre propre ensemble?

Ensuite, tout le monde peut les utiliser et être heureux sans condition.

est ici un ensemble non entièrement testé des fonctions dans le domaine public que vous pouvez utiliser à vos propres risques:

#include <string.h> 
#include <ctype.h> 

int bcmp(const void * p1, const void * p2, size_t n) 
{ 
    return memcmp(p1, p2, n); 
} 

void bcopy(const void * src, void * dst, size_t n) 
{ 
    memmove(dst, src, n); /* note different order of args - yuck */ 
} 

void bzero(void * p, size_t n) 
{ 
    memset(p, 0, n); 
} 

char *index(const char * s, int c) 
{ 
    return strchr(s, c); 
} 

char *rindex(const char * s, int c) 
{ 
    return strrchr(s, c); 
} 

int strcasecmp(const char* s1, const char* s2) 
{ 
    for (;;) { 
     int c1 = tolower(*((unsigned char*) s1++)); 
     int c2 = tolower(*((unsigned char*) s2++)); 

     if ((c1 != c2) || (c1 == '\0')) { 
      return(c1 - c2); 
     } 
    } 
} 

int strncasecmp(const char* s1, const char* s2, size_t n) 
{ 
    for (; n != 0; --n) { 
     int c1 = tolower(*((unsigned char*) s1++)); 
     int c2 = tolower(*((unsigned char*) s2++)); 

     if ((c1 != c2) || (c1 == '\0')) { 
      return(c1 - c2); 
     } 
    } 

    return(0); 
} 


int ffs(int v) 
{ 
    unsigned int x = v; 
    int c = 1; 

    /* 
    * adapted from from 
    *  http://graphics.stanford.edu/~seander/bithacks.html#ZerosOnRightBinSearch 
    * 
    * a modified binary search algorithm to count 0 bits from 
    * the right (lsb). This algorithm should work regardless 
    * of the size of ints on the platform. 
    * 
    */ 

    /* a couple special cases */ 
    if (x == 0) return 0; 
    if (x & 1) return 1; /* probably pretty common */ 

    c = 1; 
    while ((x & 0xffff) == 0) { 
     x >>= 16; 
     c += 16; 
    } 
    if ((x & 0xff) == 0) { 
     x >>= 8; 
     c += 8; 
    } 
    if ((x & 0x0f) == 0) { 
     x >>= 4; 
     c += 4; 
    } 
    if ((x & 0x03) == 0) { 
     x >>= 2; 
     c += 2; 
    } 

    c -= (x & 1); 
    c += 1;  /* ffs() requires indexing bits from 1 */ 
       /* ie., the lsb is bit 1, not bit 0 */ 
    return c; 
}