1，指针函数、函数指针、函数指针数组
2 , 自定义比较函数, 结构体，sort函数中的less算子和greater算子，优先队列的重载运算符
3 ，malloc
4 ，C语言中位运算符&和|是怎么运算的
5 ,c语言数据类型的范围
6,p++ 和 ++p
7,strlen函数和sizeof操作符
8，进制转换的方法
- 再谈C语言指针函数、函数指针、函数指针数组
1、 指针函数
指针函数就是返回指针值的函数，本质是一个函数。所以指针函数等价于“返回值为指针的函数”。
| |
2、函数指针
函数指针就是一个指向函数的指针。每个函数在编译时，会被分配一个入口地址，一般用函数名来表示，这个地址就是该函数的指针。
语法：声明形式：type (*func)(参数列表 )
从上面的定义形式可以看出，函数指针和指针函数的直观上区别在于指针符号*与函数名/指针名有没有用括号（）包裹起来，从这一点来看是很容易区分两者的。
| |
上例给出了函数指针的两种最普遍的调用形式，一个是直接用定义的指针变量(* func)调用，一个是用指针名调用，后者看起来就像是将原函数使用了新名称去调用一样，可以看成函数的别名。再次强调一下：指针变量名和指针符号 * 一定要用括号包裹起来。
3、函数指针数组
就是每个元素都是函数指针的数组，直接在函数指针名后面加上数组符号[ ]即可。
语法：声明形式：type (*func[ ])(参数列表 )
| |
4、指向函数指针数组的指针
语法：声明形式：type (* (*func )[ ])(参数列表 )
| |
5、指针，地址，引用
引用：引用是一个变量的另一个名字，又称别名。
定义方式：int a=10； int &b=a;
在这里，意思就是给a变量起了一个新名字b，因此b不可再次被重新定义。
引用必须初始化，无空引用，并且引用不分等级。
例如：交换函数swap（）
| |
变量a 本质上代表一个存储单元。CPU通过该存储单元的地址访问该存储单元中的数据。所以a本来代表两个值：存储单元的地址和储单元中的数据。于是就有了二异性。为了消除这种二义性，C语言规定a表示存储单元中的数据，&a表示存储单元的地址。
其中 要求a对应的存储单元中的数据一定是另一个存储单元的地址。
定义int× b；int a=5； b=&a；
于是， ×b表示另一个存储单元中的数据。 而给指针赋值的时候b=&a；就*b表示a对应的存储单元的地址中的数据。 &a表示a对应的存储单元的地址。
| |
6、 方法改变数组元素
| |
6、return语句
return 语句的一般形式为：
return 表达式;
或者：
return (表达式);
有没有( )都是正确的，为了简明，一般也不写( )。例如：
| |
struct Edge
{
int from, to, weight;
};
bool operator<(Edge a, Edge b)
{
//使用大于号实现小于号，表示排序顺序与默认顺序相反。若使用小于号实现小于号，则相同。可用此法方便理解。
return a.weight > b.weight;
}
| |
#include
#include
#include
#include
#include
using namespace std;
struct Edge
{
int from, to, weight;
Edge(int from, int to, int weight):from(from), to(to), weight(weight){}
};
bool operator<(Edge a, Edge b)
{
return a.weight > b.weight;//原来为<,小顶堆（从大到小），反转后为从小到大
}
int main()
{
priority_queue pq;
pq.push(Edge(0, 1, 7));
pq.push(Edge(1, 2, 4));
pq.push(Edge(2, 3, 10));
pq.push(Edge(3, 4, 5));
//默认的优先队列是最大堆（less，从大到小），使用我们定义的比较方法后反转为最小堆。
while(!pq.empty())
{
cout << pq.top().weight << endl;
pq.pop();
}
vector<Edge> vec;
vec.push_back(Edge(0, 1, 7));
vec.push_back(Edge(1, 2, 4));
vec.push_back(Edge(2, 3, 10));
vec.push_back(Edge(3, 4, 5));
sort(vec.begin(), vec.end());
//sort()函数默认为增序，这里反转为降序。
for(int i = 0; i < vec.size(); ++i)
{
cout << vec[i].weight << endl;
}
set<Edge> se;
set<Edge>::iterator iter;
se.insert(Edge(0, 1, 7));
se.insert(Edge(1, 2, 4));
se.insert(Edge(2, 3, 10));
se.insert(Edge(3, 4, 5));
//set默认为增序，这里反转为降序。
for(iter = se.begin(); iter != se.end(); ++iter)
{
cout << iter -> weight << endl;
}
return 0;
}
对应的输出为：
4
5
7
10
10
7
5
4
10
7
5
4
| |
struct Edge
{
int from, to, weight;
};
bool cmp(Edge a, Edge b)
{
return a.weight > b.weight;
}
//然后使用sort()函数
sort(data.begin(), data.end(), cmp);
| |
#include
#include
#include
using namespace std;
struct cmp
{
bool operator()(const int &a, const int &b)
{
return a > b;
}
};
int main()
{
set<int, cmp> se;
set<int, cmp>::iterator iter;
se.insert(7);
se.insert(4);
se.insert(10);
se.insert(5);
//sort()函数默认为增序，这里反转为降序。
for(iter = se.begin(); iter != se.end(); ++iter)
{
cout << *iter << endl;
}
return 0;
}
| |
#include
using namespace std;
int main(int argc, char argv[]) {
const char p = “hello”;
cout << p << endl;
cout << p++ << endl;
cout << ++p << endl;
//cout << ++p << endl; // 编译报错，*p 为一个字符，++ 不能作用于常量和表达式
int a = 6;
int *pa = &a;
cout << *pa++ << endl;
cout << ++*pa << endl;
return 0;
}
运行结果如下：
h
h
l
6
-1268913224
~~~
解读：
p++ ，由于 （取值运算符）和 ++ （自增运算符）同属第二优先级别的运算符，所以当它们同时作用于变量 p 上时，按照从右向左的结合顺序依次进行运算。所以 p++ 等同于 (p++) ：
第一步 ：执行 p++，执行完后，p 的值增加 1（此时 p 已经指向第二个字符），并且返回 p 增加前的值。
第二步：执行 *(p++)，灰色表示已经执行完了，而表达式 (p++) 的值为原始 p 的值，即还是指向字符串常量第一个字符的地址，所以最终结果为：h。
++p，按照从右向左结合的顺序，等价于 (++p)，先执行 ++p （++在前面，先加后用，在后面先用后加），执行完后，p 指向第三个字符，即 l，并且表达式 (++p) 返回 p 增加后的值，所以最终结果为 l。
类似的，pa++等价于 (pa++)，执行完的结果是：表达式值为 6（通过这个结果可以证明： 取值运算符作用的是 (pa++)表达式，而不是作用于变量 pa 本身），pa 值增加1，指向一个未知内存。当执行 ++pa 时，由于 pa 此时指向的位置未知，所以对其里面的内容进行自增运算的结果也未知，所以最终的结果为一个垃圾数。
strlen函数和sizeof操作符
| |
- 小知识
| |
进制转换
| |
- 随机数的使用
| |
206
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
