C++11语法(三)

#include <stdio.h>

// 函数指针的模拟，随便写的类型名。
// 打印数组。

// 定义函数指针
typedef void (*ptest)(int* a, int n);

void test(int* a, int n)
{
	for (int i = 0;i < n;++i)
	{
		printf("%d   ", a[i]);
	}
	printf("\n");
}

void function(ptest func,int* a,int n)
{
	func(a,n);
}

int main()
{
	int a[] = { 1,2.3,4,5,6,7,8 };
	int n = sizeof(a) / sizeof(a[0]);
	function(test,a,n);

	return 0;
}

class 类名
{
    public:
        // 运算符重载 : operator + 符号 
        // 就可以通过符号与类结合调用。
        // 这完全就是C++基于类和变量之间不同的考量。
        返回类型 operator () (参数)
        {
            ; // …………所要调用的方法和所要实现的内容。
        }
};     //这个分号千万不要忘记了，就把它当做是C语言定义变量。

#include <iostream>
#include <algorithm>

// 仿函数。
class Func
{
public:
	// 这里依据函数实现的不同而返回类型不同。
	// 还可以加入模板。
	template<typename T>
	bool operator () (T i, T j)
	{
		// 升序的话是后面的数据大于前面的数据。
		// 我们为了演示反其道而行之。
		return i > j;
	}
};

int main()
{
	int a[] = { 1 , 2 , 4 , 5 , 6 , 7 , 8 };
	int n = sizeof(a) / sizeof(a[0]);
	// 起始位置和末尾位置的下一个(有效位置的下一个，也就是无效位置。更确切的讲是规定范围。)
	// 最后一个参数是用来传递排序标准的，什么都不传的话默认是升序(缺省参数)。
	// 如果是STL容器的话直接用里面的begin函数和end函数。
	std::sort(a, a + n);
	// 范围for
	for (int x : a)
	{
		std::cout << x << "  ";
	}
	std::cout << std::endl;
	std::sort(a, a + n, Func());
	for (int x : a)
	{
		std::cout << x << "  ";
	}
	std::cout << std::endl;

	return 0;
}

[捕捉列表:值捕捉&+变量、对象=引用。值引用:变量、对象=const引用]
// 如果只有一个&，说明是引用函数中的所有变量、对象。
->返回类型（没有就省略这个->）(参数类型)
{
    ;     //…………实现的方法。
}

std::sort(a, a + n,[](int i,int j)
{
    return i > j;
});

#include <iostream>
#include <algorithm>
#include <functional>

class Func
{
public:
	void print(int* a,int n)
	{
		for (int i = 0; i < n; ++i)
		{
			std::cout << a[i] << "  ";
		}
		std::cout << std::endl;
	}
};

int main()
{
	int a[] = { 1 , 2 , 4 , 5 , 6 , 7 , 8 };
	int n = sizeof(a) / sizeof(a[0]);

	// 我们尝试使用std::function包装仿函数。
	// 还可以和模板进行搭配。
	// 调用未加static的类函数需要用到类中的指针或是引用。
	std::function<void(Func, int*, int)> func1 = &Func::print;
	func1(Func(), a, n);

	// 绑定器可以固定参数，调用更加方便，也防止别人乱改，也通过std::placeholders库中的_n来确定该输入几个参数。
	// 一般可以将std::bind看作function的初始化类型。
	// 使用std::bind赋值给std::function的时候，记得已经在bind固定了的参数的类型从function中去掉。
	// 因为参数已经固定无需再传参了。
	std::function<void(int*,int)> func2 = std::bind(&Func::print,Func(), std::placeholders::_1,
		std::placeholders::_2);
	func2(a, n);

	std::function<void()> func3 = std::bind(&Func::print, Func(), a, n);
	// 当然可以直接将所有参数都固定，直接变为无参函数。
	func3();

	return 0;
}

template<class T>
 class unique_ptr

 {
 public:
 explicit unique_ptr(T* ptr)
 :_ptr(ptr)
 {}
 ~unique_ptr()
    {
 if (_ptr)
 {
 cout << "delete:" << _ptr << endl;
 delete _ptr;
 }
 }
 // 像指针⼀样使⽤ 
 T& operator*()
 {
 return *_ptr;
 }
 T* operator->()
 {
 return _ptr;
 }
 unique_ptr(const unique_ptr<T>& sp) = delete;
 unique_ptr<T>& operator=(const unique_ptr<T>& sp) = delete;
 unique_ptr(unique_ptr<T>&& sp)
 :_ptr(sp._ptr)
 {
 sp._ptr = nullptr;
 }
 unique_ptr<T>& operator=(unique_ptr<T>&& sp)
 {
 delete _ptr;
 _ptr = sp._ptr;
 sp._ptr = nullptr;
 }
 private:
 T* _ptr;
 };
 template<class T>
 class shared_ptr

 {
 public:
 explicit shared_ptr(T* ptr = nullptr)
 : _ptr(ptr)
 , _pcount(new int(1))
 {}
 
 template<class D>
{
 return _ptr;
 }
 int use_count() const

 {
 return *_pcount;
 }
 T& operator*()
 {
 return *_ptr;
 }
 T* operator->()
 {
 return _ptr;
 }
 private:
 T* _ptr;
 int* _pcount;
 //atomic<int>* _pcount; 
 function<void(T*)> _del = [](T* ptr) {delete ptr; };
 };
 
 // 需要注意的是我们这⾥实现的shared_ptr和weak_ptr都是以最简洁的⽅式实现的， 
 // 只能满⾜基本的功能，这⾥的weak_ptr lock等功能是⽆法实现的，想要实现就要 
 // 把shared_ptr和weak_ptr⼀起改了，把引⽤计数拿出来放到⼀个单独类型，shared_ptr 
 // 和weak_ptr都要存储指向这个类的对象才能实现，有兴趣可以去翻翻源代码 
 template<class T>
 class weak_ptr
 {
 public:
     weak_ptr()
     {}
     weak_ptr(const shared_ptr<T>& sp)
         :_ptr(sp.get())
     {}
     weak_ptr<T>& operator=(const shared_ptr<T>& sp)
    {
        _ptr = sp.get();
        return *this;
    }
private:
        T* _ptr = nullptr;
    };
}