c++学习点滴2

一、函数指针

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;