5 votes

"'void*' n'est pas un type de pointeur vers un objet" dans un code sans void* ?

J'ai un problème dans mon code. Dans Xcode ou en utilisant le C++11 compilateur, ce code fonctionne bien. Cependant, lorsque je soumets ce code à un juge en ligne, le verdict indique "Erreur de compilation" . Je pense qu'ils utilisent le C++4.7.1 qui, lorsque j'ai essayé de le compiler (en utilisant Ideone), dit :

prog.cpp: In function 'void printArray(int)':
prog.cpp:27: error: 'void*' is not a pointer-to-object type
prog.cpp:27: error: 'void*' is not a pointer-to-object type
prog.cpp:27: error: 'void*' is not a pointer-to-object type
prog.cpp:27: error: 'void*' is not a pointer-to-object type
prog.cpp:27: error: 'void*' is not a pointer-to-object type
prog.cpp:27: error: 'void*' is not a pointer-to-object type
prog.cpp:27: error: 'void*' is not a pointer-to-object type
prog.cpp:27: error: 'void*' is not a pointer-to-object type
prog.cpp:27: error: 'void*' is not a pointer-to-object type
prog.cpp:27: error: 'void*' is not a pointer-to-object type
prog.cpp:27: error: 'void*' is not a pointer-to-object type
prog.cpp:27: error: 'void*' is not a pointer-to-object type

Cela n'a aucun sens car il n'y a pas void* n'importe où dans ce programme.

Mais je n'ai pas la moindre idée de ce qu'il faut changer. Ce serait formidable si vous m'aidiez à résoudre ce problème. Voici mon code :

#include <iostream>
#include <math.h>
#include <cmath>
#include <tgmath.h>

int array[10] = {1,2,3,4,5,6,7,8,9};
int initial = 1;
int tmp;
int total[500];

using namespace std;

void swap(int x, int y){
    int temp = array[x];
    array[x]=array[y];
    array[y]=temp;

    return;
}

void printArray(int size){

    int i;
    for (i=0;i<size;i++){
        //cout<<array[i]<<" ";
        tmp= array[i];
        tmp= (tmp* (pow(10.0,(size-i-1))));  // <--- Error here
        total[initial]=total[initial]+ tmp;
    }
    initial++;
    tmp=0;
    //cout<<endl;
}

void permute(int k,int size){
    int i;
    if (k==0) printArray(size);
    else{
        for (i=k-1;i>=0;i--){
            swap(i,k-1);
            permute(k-1,size);
            swap(i,k-1);
        }
    }

    return;
}

void quickSort(int arr[], int left, int right) {
    int i = left, j = right;
    int tmp;
    int pivot = arr[(left + right) / 2];

    while (i <= j) {
        while (arr[i] < pivot)
            i++;
        while (arr[j] > pivot)
            j--;
        if (i <= j) {
            tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = tmp;
            i++;
            j--;
        }
    };

    if (left < j)
        quickSort(arr, left, j);
    if (i < right)
        quickSort(arr, i, right);
}

int main(){
    int countertest;
    cin>>countertest;
    int ak, asize;

    for(int a= 0; a<countertest; a++){

        initial = 1;
        std::fill(total, total+500, 0);
        cin>>asize>>ak;
        permute(asize,asize);

        quickSort(total, 1, initial-1);

        int arraydex [10000], temp = total[ak];
        for(int z = asize; z>=0; z--){
            arraydex[z] = temp % 10;
            temp /= 10;
        }

        for(int bc = 1; bc<=asize; bc++){
            cout<<arraydex[bc]<<" ";
        }
        cout<<endl;
    }

    return 0;
}

12voto

templatetypedef Points 129554

Il s'agit ici d'un conflit entre <tgmath.h> y <cmath> / <math.h> .

Voici ce que j'ai trouvé en ouvrant le fichier source pour <tgmath.h> sur mon système Linux :

#define pow(Val1, Val2) __TGMATH_BINARY_REAL_IMAG (Val1, Val2, pow, cpow)

C'est important, ça redéfinit pow pour utiliser cette autre macro. Celle-ci est immédiatement un problème, parce que c'est #define -enlever le normal pow fonction.

Alors, que fait cette fonction ? Eh bien, regardons __TGMATH_BINARY_REAL_IMAG :

# define __TGMATH_BINARY_REAL_IMAG(Val1, Val2, Fct, Cfct) \
 (__extension__ (((sizeof (__real__ (Val1)) > sizeof (double)       \
       || sizeof (__real__ (Val2)) > sizeof (double))       \
      && __builtin_classify_type (__real__ (Val1)       \
          + __real__ (Val2)) == 8)    \
     ? ((sizeof (__real__ (Val1)) == sizeof (Val1)        \
   && sizeof (__real__ (Val2)) == sizeof (Val2))        \
  ? (__typeof ((__tgmath_real_type (Val1)) 0        \
       + (__tgmath_real_type (Val2)) 0))        \
    __tgml(Fct) (Val1, Val2)            \
  : (__typeof ((__tgmath_real_type (Val1)) 0        \
       + (__tgmath_real_type (Val2)) 0))        \
    __tgml(Cfct) (Val1, Val2))            \
     : (sizeof (__real__ (Val1)) == sizeof (double)       \
  || sizeof (__real__ (Val2)) == sizeof (double)        \
  || __builtin_classify_type (__real__ (Val1)) != 8     \
  || __builtin_classify_type (__real__ (Val2)) != 8)    \
     ? ((sizeof (__real__ (Val1)) == sizeof (Val1)        \
   && sizeof (__real__ (Val2)) == sizeof (Val2))        \
  ? (__typeof ((__tgmath_real_type (Val1)) 0        \
       + (__tgmath_real_type (Val2)) 0))        \
    Fct (Val1, Val2)              \
  : (__typeof ((__tgmath_real_type (Val1)) 0        \
       + (__tgmath_real_type (Val2)) 0))        \
    Cfct (Val1, Val2))              \
     : ((sizeof (__real__ (Val1)) == sizeof (Val1)        \
   && sizeof (__real__ (Val2)) == sizeof (Val2))        \
  ? (__typeof ((__tgmath_real_type (Val1)) 0        \
       + (__tgmath_real_type (Val2)) 0))        \
    Fct##f (Val1, Val2)             \
  : (__typeof ((__tgmath_real_type (Val1)) 0        \
       + (__tgmath_real_type (Val2)) 0))        \
    Cfct##f (Val1, Val2))))

Hum... Je ne sais pas quoi dire ici. C'est cruel et inhabituel.

Alors qu'est-ce qui se passe ici ? Eh bien, j'ai regardé les docs pour tgmath.h et a découvert que cet en-tête définit un tas de macros sensibles au type pour des fonctions de base comme pow etc. qui déterminera si le type d'argument est un double , float etc., puis envoie l'appel à la fonction appropriée. Ceci est dû au fait que le C ne supporte pas la surcharge (alors que le C++ le fait), elle doit donc être fournie par le fichier d'en-tête magique. Le détail important ici est que la fonction ne doit être appelée que sur des arguments de type double , float ou des versions complexes de ces types, et vous passez dans un fichier int . Puisque la substitution de macro se produit ici, le compilateur ne regarde même pas le fichier cmath au lieu de se jeter dans la Macro C de l'enfer qui essaie d'introspecter le type.

En bref, n'incluez pas ce fichier d'en-tête dans C++ ! C'est totalement inutile en C++ car il existe déjà un support pour les fonctions surchargées, et il y a une fonction complex Ce modèle permet de traiter les nombres complexes.

J'espère que cela vous aidera !

8voto

Shafik Yaghmour Points 42198

Pour autant que je puisse dire #include <tgmath.h> est le problème, et vous pouvez supprimer #include <math.h> également, #include <cmath> devrait être suffisante.

Si vous incluez le fichier d'en-tête C++ approprié #include <ctgmath> il semble qu'il soit correct également.

Prograide.com

Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.

Powered by:

X