一、函数指针
func.h:
#ifndef FUNC_H_
#define FUNC_H_
#include <string>
#include <iostream>
int compare(const std::string& s1, const std::string& s2); // 普通函数
typedef int (*COMP)(const std::string& s1, const std::string& s2);
void myfun(std::string *s1, std::string *s2, COMP comp=compare); // 参数中含有函数指针,可以有默认值
#endif
func.cpp:
#include "func.h"
#include <string>
#include <iostream>
int compare(const std::string& s1, const std::string& s2) {
return s1.compare(s2);
}
void myfun(std::string *s1, std::string *s2, COMP comp) {
std::cout << "myfun:comp('" << *s1 << "','" << *s2 << "'): " << comp(*s1, *s2) << std::endl;
}
main.cpp:
#include <iostream>
#include <vector>
#include "func.h"
using namespace std;
int main(int argc, char* argv[]) {
cout << "Hello World!!!" << endl;
cout << "compare('aaa','bbb'): " << compare("aaa", "bbb") << endl; // 普通调用
int (*fp)(const string&, const string&);
fp = compare;
cout << "function pointer: " << fp("aaa", "bbb") << endl; // 通过函数指针调用
fp = &compare; // 和上面等价
cout << "function pointer: " << fp("aaa", "bbb") << endl;
string s1("aaa");
string s2("bbb");
myfun(&s1, &s2, fp); // 把函数指针作为参数传到一个函数中去
return 0;
}
运行结果:
Hello World!!!
compare('aaa','bbb'): -1
function pointer: -1
function pointer: -1
myfun:comp('aaa','bbb'): -1
二、static关键字
1. 面向过程
* static全局变量:只能在本文件中访问。和普通全局变量的区别就是作用域被限制在一个文件中
* static局部变量:函数退出时仍保持其值不释放。普通的局部变量在函数退出时会被释放
* static函数:只能在本文件中访问。普通函数通过extern的方式(一般定义在头文件中)可被用于其它文件中。
2. 面向过程
* static属性或方法:属于类而非某个对象。不能调用非static成员,当非static成员可以调用它。这个和JAVA没有区别
三、namespace
作用就是在全局命名空间(::)中继续划分子空间。子空间的定义会覆盖父空间的定义。和JS中的域差不多。
1.定义
namespace MySpace {
// 各种定义
namespace InnerSpace1{ // 可以嵌套
// 各种定义,会覆盖外层同名的定义
}
}
2. 使用
* MySpace::xxx // 直接使用域前缀的方式去访问该命名空间下的成员
* using MS=MySpace; // 别名
MS::xxx // 使用域前缀的方式访问。类似于JAVA的全类名java.util.List
* using MySpace::xxx; // 使xxx可见。类似于JAVA的import java.util.List;
xxx.fun(); // 类似于JAVA的ist.add();
* using MySpace; // 使该空间下的所有成员可见。类似于JAVA的import java.util.*;
xxx.fun();
四、函数重载
* 函数名相同,参数的个数、类型、顺序不同
* 不考虑返回类型,不考虑参数名称
* 不考虑形参的const,volatile修饰符 (指针和引用类型的除外)
* 只考虑typedef所代表的底层类型
* 不考虑形参是否缺省
五、函数的几种返回类型
class Test {
public :
Test(){val=0;}
Test(int v) {
val = v;
}
~Test(){val=-1;}
inline int get(){return val;}
inline void set(int v){val = v;}
private :
int val;
};
Test getTest1() {
// Test t(100);
// return t; // 会调用拷贝构造,然后析构t
// Test t(100);
// Test &rt = t;
// return rt; // 同上
Test *t = new Test(100);
return *t; // 会照成内存泄露。函数结束后,t变量消失,但其所指向的对象没有释放(delete t)
}
Test& getTest2() {
// Test t(100);
// return t; // 函数结束后t被析构,返回值指向一个无效的内存区域
// Test t(100);
// Test& rt = t;
// return rt; // 同上
Test *t = new Test(100);
return *t; // 函数结束后t消失,而返回的引用指向了被new出来的内存。但是因为返回的不是一个指针,所以无法通过delete去释放这块内存,造成内存泄露
}
Test* getTest3() {
// Test t(100);
// return &t; // 函数结束后t被析构,返回的指针变成野指针
// Test t(100);
// Test &rt = t;
// return &rt; // 同上
Test *t = new Test(100);
return t; // 较好
}
void f () {
Test t = getTest1();
cout << t.get() << endl;
// Test t = getTest2();
// cout << t.get() << endl;
// Test *pt = getTest3();
// cout << pt->get() << endl;
}
int main(int argc, char* argv[]) {
f();
return 0;
}
六、引用基本知识
引用的主要作用是: 1.函数形参 2. 函数返回值 3. const引用
int i = 100;
int &ri = i; // 引用的声明
cout << "ri=" << ri << endl;
int &rri = ri; // 这里的ri就是i,实际上相当于: int &rri = i;为i分配了第二个别名rri
cout << "rri=" << rri << endl;
int j = ri; // 相当于i=j
cout << "j=" << j << endl;
int k = 200;
const int &rk = k; // 常引用
//rk = 300; // 不能通过常引用去修改k
k = 300; // 但是我们可以直接修改k
cout << "rk=" << rk << endl; // 300
int &nrk = k; // k的第二个别名(注意是非const引用)
nrk = 400; // 通过nrk可以修改k,此时的rk跟着一起变
cout << "rk=" << rk << endl;