有几种明显的使用方法qsort：在比较器中强制转换：
int cmp(const void *v1, const void *v2)
{
const double *d1 = v1, *d2 = v2;
?
}
qsort(p, n, sizeof(double), cmp);
或投射比较器：
int cmp(const double *d1, const double *d2)
{
?
}
qsort(p, n, sizeof(double), (int (*)(const void *, const void *))cmp);
我倾向于使用前者，更多的是出于审美原因。是否有任何技术上的原因偏爱其中一个？
假设我在C中有一个指向char的指针数组:
char *data[5] = { "boda", "cydo", "washington", "dc", "obama" };
我希望使用qsort对这个数组进行排序:
qsort(data, 5, sizeof(char *), compare_function);
我无法提出比较功能.由于某种原因,这不起作用:
int compare_function(const void *name1, const void *name2)
{
const char *name1_ = (const char *)name1;
const char *name2_ = (const char *)name2;
return strcmp(name1_, name2_);
}
我做了很多搜索,发现我必须**在qsort里面使用:
int compare_function(const void *name1, const void *name2)
{
const char *name1_ = *(const char **)name1;
const char *name2_ = *(const char **)name2;
return strcmp(name1_, name2_);
}
这很有效.
任何人都可以解释*(const char **)name1这个功能的使用吗？我根本不明白.为什么双指针？为什么我原来的功能不起作用？
谢谢,Boda …
我假设stdlib中的旧的qsort函数不稳定,因为手册页没有说明任何内容.这是我正在谈论的功能:
#include <stdlib.h>
void qsort(void *base, size_t nmemb, size_t size,
int(*compar)(const void *, const void *));
我假设如果我改变我的比较函数也包括我正在比较的地址,它将是稳定的.那是对的吗？
例如:
int compareFoos( const void* pA, const void *pB ) {
Foo *pFooA = (Foo*) pA;
Foo *pFooB = (Foo*) pB;
if( pFooA->id < pFooB->id ) {
return -1;
} else if( pFooA->id > pFooB->id ) {
return 1;
} else if( pA < pB ) {
return -1;
} else if( pB > pA ) {
return 1;
} else {
return …我正在尝试学习c ++并尝试使用sort和qsort.sort()工作正常,但qsort没有,我不知道为什么,所以你可以帮助我,这是我试图编译的代码
#include<iostream>
#include<vector>
#include<cstdlib>
#include<ctime>
#include<algorithm>
using namespace std;
int compvar(const void *one, const void *two)
{
int a = *((int*)one);
int b = *((int*)two);
if (a<b)
return -1;
if (a == b)
return 0;
return 1;
}
void bvect(vector<int> &vec, int num)
{
srand(time(NULL));
for(int i=0; i<num; ++i)
vec.push_back(rand()%1000 + 1);
}
void showvec(vector<int> vec)
{
for (int i=0; i<vec.size(); ++i)
cout<<vec[i]<<endl;
}
int main()
{
vector<int>numbers;
bvect(numbers, 1000);
showvec(numbers);
qsort(numbers.begin(), numbers.size(), sizeof(int), compvar);
showvec(numbers);
return 0;
}
我正在编写一个函数,它接收一个指向比较函数的指针和一个数组,MyStructs并且应该根据比较函数对数组进行排序:
void myStructSort(
struct MyStruct *arr,
int size,
int (*comp)(const struct MyStruct *, const struct MyStruct *)) {
qsort(arr, size, sizeof(struct MyStruct), comp);
}
不幸的是,这不会编译,因为qsort期望比较器接收void *参数而不是const struct MyStruct *.我想到了几个不好的解决方案,并想知道正确的解决方案是什么.
选项1
铸造comp到int (*)(const void *, const void*).这编译但是未定义的行为(参见这个问题).
选项2
创建一个全局变量int (*global_comp)(const struct MyStruct *, const struct MyStruct *),并设置global_comp=comp里面myStructSort.然后创建一个函数:
int delegatingComp(const void *a, const void *b) {
return globalComp((const struct MyStruct *)a, (const …我不知道我做错了什么,但以下代码没有正确排序数组.
#include <stdio.h>
#include <stdlib.h>
int compare(const void* a, const void* b)
{
return (*(int*)a - *(int*)b);
}
int main()
{
int x[] = { -919238029,
-889150029,
-826670576,
-579609061,
-569653113,
-305140505,
-216823425,
-193439331,
-167683147,
-49487019,
-45223520,
271789961,
275570429,
444855014,
559132135,
612312607,
664554739,
677860351,
1005278191,
1031629361,
1089012280,
1115952521,
1521112993,
1530518916,
1907515865,
1931470931,
-1631034645,
-1593702794,
-1465300620,
-1263094822
};
int i;
qsort(x, 30, sizeof(int), compare);
for(i = 0; i < 30; i ++)
printf("%d\n", x[i]);
return 0;
}
产生以下输出:
1521112993
1530518916
1907515865
1931470931 …我试图找出如何在C中对多维数据(5维)进行排序.我知道使用5d数组是一个解决方案,通过阅读关于此主题的其他帖子,许多人发现,如果不是完全不道德的,那么美学上令人厌恶,以便引发不断的抛射物呕吐...所以我提前道歉.
基本上我有一组传入的数据,我必须应用一系列离散算法.每个算法都有一组变量,我需要计算每个算法效率的排名,每个变量的排列都是可能的.最终,我需要一个按最差到最差的算法排序的列表.整个计算是动态的,因此对于一个传入的数据最有效的方法不太可能是另一个数据的最佳表现者......所以我无法消除任何变量,因为它们表现不佳.
以下是数据的外观:
dataValue[ algo ][ lengthVar ][ durationVar ][ plasticityVar ] [ fungibilityVar]
有:
除了按算法排序之外,我还希望能够灵活地对5个维度中的任何维度进行排序.
这将使用VS 2010 C(非C++)在具有192 gig(非meg)RAM的12个物理/ 24逻辑核心机器上运行.
我假设qsort将是最有效的排序选项.我已经广泛搜索谷歌和SO如何做到这一点无济于事.有1d数组的答案,PHP或C#中的多维数组等,但不适用于C ...或者至少我找不到一个.
我正在使用这个比较函数来排序一个由long long int组成的数组.
int compare(const void * p1,const void * p2)
{
return (* (long long int * )a-*(long long int * )b);
}
qsort(array,no of elements,sizeof(long long int),compare)
这适用于小的nos但是当数组包含10 ^ 10的nos时它会得到错误的结果吗？
我犯的错是什么？
#include <stdio.h>
#include <stdlib.h>
float values[] = { 4, 1, 10, 9, 2, 5, -1, -9, -2,10000,-0.05,-3,-1.1 };
int compare (const void * a, const void * b)
{
return ( (int) (*(float*)a - *(float*)b) );
}
int main ()
{
int i;
qsort (values, 13, sizeof(float), compare);
for (i = 0; i < 13; i++)
{
printf ("%f ",values[ i ]);
}
putchar('\n');
return 0;
}
结果是:
-9.000000 -3.000000 -2.000000 -1.000000 -1.100000 -0.050000 1.000000 2.000000 4.000000 5.000000 9.000000 10.000000 …
我正在编写一个可加载的内核模块,我需要使用qsort()显然不能在内核空间中使用的函数.
我可以使用具有类似功能的功能吗？
(内核版本3.5.0)