函数指针、类型别名与智能指针

 1 // run in windows: std::system("pause")
 2 #include <cstdlib>
 3 #include <iostream>
 4 #include <memory>
 5 #include <functional>
 6
 7 using namespace std;
 8 using namespace std::placeholders;
 9
10 template <typename T>
11 using DeleteFunc = void(T*);
12
13 class Deleter;
14
15 template <typename T>
16 using DeleteMemberFunc = void(__thiscall Deleter::*)(T*)const;
17
18 // normal version
19 template <typename T>
20 inline void Delete(T* ptr)
21 {
22     cout << "[delete] address: " << ptr << ", value: " << *ptr << endl;
23     delete ptr;
24 }
25
26 // caller operator & static member function
27 class Deleter
28 {
29 public:
30     Deleter() = default;
31     ~Deleter() = default;
32     Deleter(const Deleter&) = default;
33     Deleter(Deleter&&) = default;
34     Deleter& operator=(const Deleter&) = default;
35
36     template <typename T>
37     void operator()(T* ptr) const { Delete(ptr); }
38
39     template <typename T>
40     static void StaticDelete(T* ptr) { ::Delete(ptr); }
41 } deleter;
42
43 // std::function
44 function<DeleteFunc<int>> funcobj = &Delete<int>;
45 function<DeleteFunc<int>> static_funcobj = &Deleter::StaticDelete<int>;
46 function<DeleteFunc<int>> member_funcobj = bind(&Deleter::operator()<int> , &deleter, _1);
47
48 // lambda
49 auto lambda_delete = [](int* ptr) { Delete(ptr); };
50
51 using IntSPtr = shared_ptr<int>;
52 template <typename Func> using IntUPtr = unique_ptr<int, Func>;
53
54 int main(int argc, char* argv[])
55 {
56     {
57         DeleteMemberFunc<int> member_func = &Deleter::operator();
58
59         IntSPtr s1 = make_shared<int>(10);
60         IntSPtr s2(new int(11), &Delete<int>);
61         IntSPtr s3(new int(12), Deleter());
62         IntSPtr s4(new int(13), &Deleter::StaticDelete<int>);
63         IntSPtr s5(new int(14), funcobj);
64         IntSPtr s6(new int(15), static_funcobj);
65         IntSPtr s7(new int(16), member_funcobj);
66         IntSPtr s8(new int(17), lambda_delete);
67         int* sp9 = new int(18);
68         (deleter.*member_func)(sp9);
69
70         unique_ptr<int> u1 = make_unique<int>(20);
71         IntUPtr<DeleteFunc<int>*> u2(new int(21), &Delete<int>);
72         IntUPtr<Deleter> u3(new int(22), Deleter());
73         IntUPtr<DeleteFunc<int>*> u4(new int(23), &Deleter::StaticDelete<int>);
74         IntUPtr<decltype(funcobj)> u5(new int(24), funcobj);
75         IntUPtr<decltype(static_funcobj)> u6(new int(25), static_funcobj);
76         IntUPtr<decltype(member_funcobj)> u7(new int(26), member_funcobj);
77         IntUPtr<decltype(lambda_delete)> u8(new int(27), lambda_delete);
78         int* up9 = new int(28);
79         (deleter.*member_func)(up9);
80     }
81
82     std::system("pause");
83     return 0;
84 }
时间: 2024-07-31 08:05:41

函数指针、类型别名与智能指针的相关文章

c++函数参数类型-值,指针,引用

    以" 值传递"方式向函数传递参数 在编写个人函数的时候,你将会受到C++中的一条基本的原则的限制:在默认的情况下,变量只能以值传递的方式传递给函数.这句话的意思是:被传递到函数的只是变量的值,永远不是变量的本身. 例如: void changeValue(int originalValue,int newValue){     originalValue = newValue;   }      int main(){     int myNum=20;     changeV

【C++】智能指针详解(一):智能指针的引入

智能指针是C++中一种利用RAII机制(后面解释),通过对象来管理指针的一种方式. 在C++中,动态开辟的内存需要我们自己去维护,在出函数作用域或程序异常退出之前,我们必须手动释放掉它,否则的话就会引起内存泄漏. 例如:我们用指针变量来创建对象时,需要手动来删除它 string * pstr = new string("hello world!"); .... delete pstr; 事实上,即使我们非常谨慎,但有时候的一些情况仍然会让我们防不胜防: //情况一:在程序某个分支内,忘

enote笔记法使用范例(2)——指针(1)智能指针

要知道什么是智能指针,首先了解什么称为 “资源分配即初始化” what RAII:RAII—Resource Acquisition Is Initialization,即“资源分配即初始化” 在<C++ Primer>这样解释的,“通过定义一个类来封装资源的分配和释放,可以保证正确释放资源” 核心:C++98提供了语言机制:对象([!值语意对象])在超出作用域,,析构函数会被自动调用 [如果构造函数中抛出异常,则不会调用析构函数.只有构造函数正确地执行,构建对象成功,才会调用析构函数] &l

#运算符、不同的指针类型、数组和指针、指针运算、堆、栈、静态区、只读区、下标VS指针

#运算符:用于在预编译期将宏参数转换为字符串 #define CONVERS(x)  #x   //注:没用双引号包括. 不同类型的指针占用的内存空间大小相同. 局部变量 定义: a[5]; 打印a[i]时,a[i]为随机数. 若定义a[5]={1,2}; 打印时,a[0]=1;a[1]=2;a[2]=a[3]=a[4]=0; 数组地址与数组名: 1.数组名代表数组首元素的地址.  a=&a[0]; 2.数组的地址需要用取地址符号&才能得到 (&a) 3.数组首元素的地址值与数组的

引用内部函数绑定机制,R转义字符,C++引用,别名,模板元,宏,断言,C++多线程,C++智能指针

 1.引用内部函数绑定机制 #include<iostream> #include<functional> usingnamespacestd; usingnamespacestd::placeholders; //仿函数.创建一个函数指针,引用一个结构体内部或者一个类内部的共同拥有函数 structMyStruct { voidadd(inta) { cout <<a <<endl; } voidadd2(inta,intb) { cout <&

【C/C++学院】0816-引用包装器/仿函数/转义字符 R”()”/using别名/模板元编程 比递归优化/智能指针/多线程/静态断言以及调试技能的要求 assert

引用包装器  std::ref(变量) #include<iostream> template<class T> void com(T arg)//模板函数,引用无效,引用包装器 { std::cout <<"com ="<< &arg << "\n"; arg++; } void main() { int count = 10; int & rcount = count; com(coun

函数指针(函数指针作为函数形参/函数类型作为函数返回类型)

函数指针是指向函数的指针变量. 因此"函数指针"本身首先应是指针变量,只不过该指针变量指向函数.这正如用指针变量可指向整型变量.字符型.数组一样,这里是指向函数.如前所述,C在编译时,每一个函数都有一个入口地址,该入口地址就是函数指针所指向的地址.有了指向函数的指针变量后,可用该指针变量调用函数,就如同用指针变量可引用其他类型变量一样,在这些概念上是大体一致的.函数指针有两个用途:调用函数和做函数的参数. 1 #include<stdio.h> 2 int max(int

C++智能指针简单剖析

导读 最近在补看<C++ Primer Plus>第六版,这的确是本好书,其中关于智能指针的章节解析的非常清晰,一解我以前的多处困惑.C++面试过程中,很多面试官都喜欢问智能指针相关的问题,比如你知道哪些智能指针?shared_ptr的设计原理是什么?如果让你自己设计一个智能指针,你如何完成?等等--.而且在看开源的C++项目时,也能随处看到智能指针的影子.这说明智能指针不仅是面试官爱问的题材,更是非常有实用价值. 下面是我在看智能指针时所做的笔记,希望能够解决你对智能指针的一些困扰. 目录

第十一章:使用智能指针管理对象资源

前言 在前面的文章中,细致地分析了构造函数,拷贝构造函数,赋值运算符,析构函数这几个类中最重要函数的用法. 如果严格地遵循这些做法,可以消除绝大部分资源管理的问题. 然而,要想更灵活的使用对象中的资源,仅仅这些还不够.譬如,若你想自己控制对象资源的生命周期(不要在作用域结束的时候自动被析构掉),那就应当好好考虑下智能指针了. 有人说,智能指针是属于设计模式范畴的产物,这么说有点偏激,但也确实有点道理. 问题分析 我们假定有一个投资类Investment: 1 class Investment 2