什么是由原始的指针和函数指针在C / C ++支持的操作? [英] What are the operations supported by raw pointer and function pointer in C/C++?
问题描述
什么是由函数指针支持的所有操作从原始指针会有所不同?
是>,< ,< =,> =由原始指针支持若然是利用运营商?
What are all operations supported by function pointer differs from raw pointer? Is > , < , <= , >=operators supported by raw pointers if so what is the use?
推荐答案
对于这两个函数和对象指针,它们编译,但其结果只能保证是相同的完整对象的子对象的地址是一致的(你可以比较一类或数组的两个成员),如果你比较函数或对象对本身。
For both function and object pointers, they compile but their result is only guaranteed to be consistent for addresses to sub-objects of the same complete object (you may compare the addresses of two members of a class or array) and if you compare a function or object against itself.
使用的std ::以下&LT;&GT;
,的std ::更大&LT;&GT;
等会工作与任何指针类型,并且将提供一致的结果,即使各自内置的操作的结果是不确定的:
Using std::less<>
, std::greater<>
and so on will work with any pointer type, and will give consistent results, even if the result of the respective built-in operator is unspecified:
void f() { }
void g() { }
int main() {
int a, b;
///// not guaranteed to pass
assert((&a < &b) == (&a < &b));
///// guaranteed to pass
std::less<int*> lss1;
assert(lss1(&a, &b) == lss1(&a, &b));
// note: we don't know whether lss1(&a, &b) is true or false.
// But it's either always true or always false.
////// guaranteed to pass
int c[2];
assert((&c[0] < &c[1]) == (&c[0] < &c[1]));
// in addition, the smaller index compares less:
assert(&c[0] < &c[1]);
///// not guaranteed to pass
assert((&f < &g) == (&f < &g));
///// guaranteed to pass
assert((&g < &g) == (&g < &g));
// in addition, a function compares not less against itself.
assert(!(&g < &g));
///// guaranteed to pass
std::less<void(*)()> lss2;
assert(lss2(&f, &g) == lss2(&f, &g));
// note: same, we don't know whether lss2(&f, &g) is true or false.
///// guaranteed to pass
struct test {
int a;
// no "access:" thing may be between these!
int b;
int c[1];
// likewise here
int d[1];
test() {
assert((&a < &b) == (&a < &b));
assert((&c[0] < &d[0]) == (&c[0] < &d[0]));
// in addition, the previous member compares less:
assert((&a < &b) && (&c[0] < &d[0]));
}
} t;
}
那一切都应该编译虽然(尽管编译器是免费的警告它想要的任何code段)。
Everything of that should compile though (although the compiler is free to warn about any code snippet it wants).
因为函数类型具有指针对象类型没有的sizeof
价值,业务遍及的术语定义的sizeof
即会没有工作,其中包括:
Since function types have no sizeof
value, operations that are defined in terms of sizeof
of the pointee type will not work, these include:
void(*p)() = ...;
// all won't work, since `sizeof (void())` won't work.
// GCC has an extension that treats it as 1 byte, though.
p++; p--; p + n; p - n;
单目 +
适用于任何指针类型,并且将只返回它的价值,没有什么特别之处函数指针。
The unary +
works on any pointer type, and will just return the value of it, there is nothing special about it for function pointers.
+ p; // works. the result is the address stored in p.
最后请注意,一个指向一个函数的指针的不是一个函数指针了:
Finally note that a pointer to a function pointer is not a function pointer anymore:
void (**pp)() = &p;
// all do work, because `sizeof (void(*)())` is defined.
pp++; pp--; pp + n; pp - n;
这篇关于什么是由原始的指针和函数指针在C / C ++支持的操作?的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持IT屋!