de acuerdo a este sitio

http://www.cplusplus.com/reference/clibrary/cstdlib/qsort/

he hecho el siguiente programa que ordena las cadenas de

#include <cstdlib>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char list[5][4]={"dat","mai","lik","mar","ana"};
int main(int argc, char *argv[])
{
    int x;
    puts("sortirebamde:");
     for (x=0;x>sizeof(list)/sizeof(char);x++)
     printf("%s\n",list[x]);
      qsort(&list,(sizeof(list)/sizeof(char)),sizeof(list[0]),strcmp);
    system("PAUSE");
    return EXIT_SUCCESS;
}

Aquí está el error

13 C:\Documents and Settings\LIBRARY\Desktop\string_sortireba.cpp invalid conversion from `int (*)(const char*, const char*)' to `int (*)(const void*, const void*)' 
13 C:\Documents and Settings\LIBRARY\Desktop\string_sortireba.cpp   initializing argument 4 of `void qsort(void*, size_t, size_t, int (*)(const void*, const void*))' 

Por favor, ayudar

Esto no es una buena manera de ordenar las cadenas en C, probablemente debería ordenar una matriz de char *, no una matriz de dos dimensiones con cadenas de longitud fija.
debe ser: for (x=0;x<sizeof(lista)/sizeof(char);x++)

OriginalEl autor user466444 | 2010-09-21

5 Comentarios

  1. 11

    Nota: no es inusual para almacenar las cadenas de C en dos dimensiones char matrices. Es más normal tener char *ary[], tales como argv. Que tipo que no se puede ordenar directamente a través de qsort y strcmp, porque qsort pasará char ** no char * a la función de comparación. Esto es bueno para la eficiencia, los indicadores pueden ser intercambiadas en lugar de la totalidad de las cadenas. El Linux manual para qsort tiene algunos buenos código de ejemplo con una correcta función de comparación.

    No se puede pasar strcmp directamente a qsort como su función de comparación porque qsort espera para pasar punteros a void donde strcmp espera punteros a const char. Dados los requisitos de la similitud entre los punteros a void y punteros a char, podría probablemente lo haría con un molde (el código), pero el modo más limpio sería escribir una función que toma a la derecha tipos:

    int cmpstr(void const *a, void const *b) { 
        char const *aa = (char const *)a;
        char const *bb = (char const *)b;
    
        return strcmp(aa, bb);
    }

    Nota, sin embargo, que en C++ normalmente usted querrá usar std::sort en lugar de qsort, y probablemente el uso de std::string en lugar de char *, en cuyo caso la clasificación se presenta mucho más sencillo (y más rápido).

    Esta función va a trabajar para la cuestión que se plantea, pero que no es una buena manera de ordenar las cadenas. Esto no funcionará para ordenar un array de char *, como qsort pasará char ** a la función.
    Que yo me aclare. Estás downvoting porque respondió a la pregunta, en lugar de decirle cómo hacer algo casi (pero no del todo) completamente diferente de lo que había pedido?
    Ok, tal vez eso es injusto. He propuesto una edición a su respuesta y le quitó la downvote si la edición es aceptado. (no se puede quitar ahora mismo debido a «las reglas» )
    para completar el elenco de la versión versión sería: (int ()(const void, const void *))strcmp), consulte el ejemplo

    OriginalEl autor Jerry Coffin

  2. 1

    El cuarto argumento de qsort tarda de 2 void* punteros como argumentos.Así que es necesario definir una función de comparación para el tuyo.
    se refieren a este enlace para obtener más detalles.

    OriginalEl autor Raghuram

  3. 0

    Más allá de por qué qsort falla, no lo utilice en C++.

    #include <algorithm>
    #include <iostream>
    #include <iterator>
    #include <string>
    
    char const* const raw_data[5] = {"dat", "mai", "lik", "mar", "ana"};
    
    std::vector<std::string> data (raw_data, raw_data + 5);
    //would rarely be a global
    
    //see below for code that needs to go here
    
    int main() {
      using namespace std;
      cout << "before: " << data << "\n";
      sort(data.begin(), data.end());
      cout << "after: " << data << "\n";
      return 0;
    }

    Boost ha secuencia de inserción de las sobrecargas a la salida de un vector directamente, pero aquí es una versión simple. Esto va en un encabezado, en lugar de ser copiado y pegado continuamente:

    template<class Stream, class Iter, class Ch>
    void write_sequence(Stream& s, Iter begin, Iter end, Ch const* initial, Ch const* sep, Ch const* final) {
      if (initial) {
        s << initial;
      }
      if (begin != end) {
        s << *begin;
        ++begin;
        for (; begin != end; ++begin) {
          if (sep) {
            s << sep;
          }
          s << *begin;
        }
      }
      if (final) {
        s << final;
      }
    }
    
    template<class T, class A>
    std::ostream& operator<<(std::ostream& s, std::vector<T,A> const& value) {
      write_sequence(s, value.begin(), value.end(), "[", ", ", "]");
      return s;
    }

    OriginalEl autor

  4. 0

    Puede pasar strcmp directamente a qsort

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    char list[5][4]={"dat","mai","lik","mar","ana"};
    int main(int argc, char *argv[]) {
        int x;
        puts("unsorted:");
        for (x=0;x<sizeof(list)/sizeof(list[0]);x++)
            printf("%s\n",list[x]);
    
        qsort(list,sizeof(list)/sizeof(list[0]),sizeof(list[0]),strcmp);
    
        puts("sorted:");
        for (x=0;x<sizeof(list)/sizeof(list[0]);x++)
            printf("%s\n",list[x]);
    // system("PAUSE");
        return EXIT_SUCCESS;
    }

    uso de la C, no C++

    No pasan strcmp directamente a qsort, en el caso normal (ordenar un array de char *) no va a funcionar, y es siempre un tipo de violación.

    OriginalEl autor user3551286

  5. 0

    Más al Estilo C++ – hoy en día – con static_cast:

    int scmp(const void * s1, const void * s2)
    {
        const char* _s1 = *static_cast<const char* const*>(s1);
        const char* _s2 = *static_cast<const char* const*>(s2);
        return strcmp(_s1, _s2);
    }

    Y en main():

    char *str_arr[] = { "one", "two", "three" };
    qsort(str_arr, sizeof(str_array)/sizeof(char*), sizeof(char*), scmp);

    Mucho más fácil es con el vector y std::ordenar.

    OriginalEl autor abutux

Dejar respuesta

Please enter your comment!
Please enter your name here