C++类基础（九）

最新推荐文章于 2023-10-07 12:47:43 发布
最新推荐文章于 2023-10-07 12:47:43 发布
阅读量590 收藏 1
点赞数
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34762931/article/details/128946042
版权

字面值类，成员指针与 bind 交互
● 字面值类：可以构造编译期常量的类型
– 其数据成员需要是字面值类型

#include<iostream>
#include<string>
class Str
{
public:
    Str(int val) //在运行期执行，导致#1处的错误
        : x(val)
    {}
private:
    int x = 3;
};

constexpr int a = 3; //OK，编译期字面值常量

constexpr Str a(3); //#1Error: Constexpr variable cannot have non-literal type 'const Str'
int main()
{
    return 0;
}

– 提供 constexpr / consteval 构造函数 （小心使用 consteval ）

#include<iostream>
#include<string>
class Str
{
public:
    constexpr Str(int val) //提供constexpr构造函数
        : x(val)
    {}
private:
    int x = 3;
};

constexpr Str a(3); //OK

int main()
{
    return 0;
}

#include<iostream>
#include<string>
//clang++
class Str
{
public:
    consteval Str(int val) //OK since C++20，consteval修饰一个函数，每次调用该函数都会返回一个编译期常量。编译期/运行期调用该函数就会返回一个编译期/运行期常量，即既可以在编译期使用也可以在运行期使用
        : x(val)
    {}
private:
    int x = 3;
};

constexpr Str a(3);

int main()
{
    return 0;
}

class Str
{
public:
    consteval Str(int val) //Error: Unknown type name 'consteval'
        : x(val)
    {}
private:
    int x = 3;
};

constexpr Str a(3);

int main()
{
    int x;
    Str a(x); //--std=c++2a x86-64 clang 10.0.1 OK
    Str b(x); //--std=c++2a x86-64 clang 11.0.0 Error: Call to consteval function 'Str::Str' is not a constant expression
    Str c(x); //--std=c++2a x86-64 clang 12.0.1 Error: Call to consteval function 'Str::Str' is not a constant expression
    Str d(x); //--std=c++2a x86-64 gcc9.4 Error: 'consteval' does not name a type
    Str e(x); //--std=c++2a x86-64 gcc10.1 Error: the value of 'x' is not usable in a constant expression
    return 0;
}

– 平凡的析构函数

class Str
{
public:
    constexpr Str(int val)
        : x(val)
    {}
    //~Str() = default; //平凡的析构函数，即编译器合成的析构函数（不写此行）
    ~Str() {} //#1即使函数体为空也是用户定义的析构函数的逻辑，运行期销毁对象时调用
private:
    int x = 3;
};

constexpr Str a(3); //编译器无法知道在编译期如何销毁该对象，使用#1处的析构导致编译失败

int main()
{
    return 0;
}

– 提供 constexpr / consteval 成员函数 （小心使用 consteval ）

class Str
{
public:
    constexpr Str(int val) //可在编译期调用，也可在运行期调用
        : x(val)
    {}
    Str(double f) //只能在运行期调用
        : x(f)
    {}
    constexpr int funexpr() const
    {
        return x+1;
    }
    consteval int funeval() const
    {
        return x+1;
    }
private:
    int x = 3;
};

constexpr Str a(3);

int main()
{
    Str b(3.0);
    b.funexpr(); //OK
    Str a(5.0);
    a.funeval(); //--std=c++2a x86-64 gcc 10.1 Error
    return a.funexpr(); //OK
}

– 注意：从 C++14 起 constexpr / consteval 成员函数非 const 成员函数

class Str
{
public:
    constexpr Str(int val)
        : x(val)
    {}
    constexpr int fun() //C++11时constexpr函数缺省为const，即constexpr int fun() const，通常constexpr函数体只能包含一条返回语句
        return x+1;
    }
private:
    int x = 3;
};

constexpr Str a(3);

int main()
{
    return a.fun(); //OK, a是const变量
}

class Str
{
public:
    constexpr Str(int val)
        : x(val)
    {}
    constexpr int fun() const //C++14时constexpr函数缺省为非const，所以加入const修饰符
    {
        return x+1;
    }
private:
    int x = 3;
};

int main()
{
    return a.fun(); //Error: 'this' argument to member function 'fun' has type 'const Str', but function is not marked const
}

constexpr int MyFun(int x) //C++14可以引入复杂的逻辑，函数体内的变量i是可以改变的，所以缺省是非const
{
    for(int i=0;i<10;++i)
    {
        x += i;
    }
    return x;
}

class Str //字面值类
{
public:
    constexpr Str(int val)
        : x(val)
    {}
    constexpr int fun() const //C++14时constexpr函数缺省为非const，所以加入const修饰符
    {
        return x+1;
    }
    constexpr void inc()
    {
        x = x +1;
    }
    constexpr int read() const
    {
        return x;
    }
private:
    int x = 3;
};

constexpr int MyFun()
{
    Str x(10);
    x.inc(); //可以通过constexpr void inc()修改字面值对象的中间状态
    x.inc();
    x.inc();
    return x.read();
}
int main()
{
    std::cout << MyFun() << std::endl;
    return 0;
}

在这里插入图片描述

● 成员指针
– 数据成员指针类型示例： int A::;
– 成员函数指针类型示例： int (A::)(double);

#include<type_traits>
class Str
{
};
class Str2
{
};

int main()
{
    int Str::*ptr; //ptr的类型是int Str::，ptr指向的基本类型是int，ptr位于类Str中
    void (Str::* ptr_fun)(); //ptr_fun的类型是void (Str::) ()。ptr_fun指向的基本类型是一个返回值为void的函数，ptr_fun位于类Str中
    int Str2::*ptr2;
    std::cout << std::is_same_v<decltype(ptr), decltype(ptr2)> <<std::endl; //因为ptr1和ptr2隶属不同的类，所以它俩类型不同
    return 0;
}

在这里插入图片描述

class Str
{
public:
    int x = 10;
};
class Str2
{
public:
    int y = 10;
};
int main()
{
    int Str::*ptr = &Str::x;
    int Str2::*ptr2 = &Str2::y;
    ptr2-ptr; //Error: Invalid operands to binary expression ('int Str2::*' and 'int Str::*')
    return 0;
}

– 成员指针对象赋值： auto ptr = &A::x;

class Str
{
public:
    int x = 10;
};
class Str2
{
public:
    int y = 10;
};
int main()
{
    int Str::*ptr = &Str::x; //using MemberVarPtr_13 = int Str::*; MemberVarPtr_13 ptr = &Str::x;
    int Str2::*ptr2 = &Str2::y; //  using MemberVarPtr_14 = int Str2::*; MemberVarPtr_14 ptr2 = &Str2::y;
    return 0;
}

class Str
{
public:
    int x = 10;
    int y = 10;

    void fun() {};
    void fun(double) {};
};
int main()
{
    int Str::*ptr = &Str::x;
    int Str::*ptr2 = &Str::y;
    void (Str::* ptr_fun) () = &Str::fun; //OK
    auto ptr_fun2= &Str::fun; //Error: Variable 'ptr_fun2' with type 'auto' has incompatible initializer of type '<overloaded function type>'
    return 0;
}

class Str
{
public:
    int x = 10;
    int y = 10;

    void fun() {};
};
int main()
{
    int Str::*ptr = &Str::x;
    int Str::*ptr2 = &Str::y;
    void (Str::* ptr_fun) () = &Str::fun; //OK
    auto ptr_fun2= &Str::fun; //OK
    return 0;
}

● 注意域操作符子表达式不能加小括号（否则 A::x 一定要有意义）

class Str
{
public:
    int x;
    int y;

    void fun() {};
};
int main()
{
    int Str::*ptr = &(Str::x); //Error: Invalid use of non-static data member 'x'
    return 0;
}

class Str
{
public:
    static int x; //静态变量
    int y;

    void fun() {};
};
int main()
{
    //ptr类型是int Str::*， &(Str::x）类型是int*，因为类Str中的x是静态整型，不依赖于类对象，单独占某块内存
    //int Str::*ptr = &(Str::x); //Error: Cannot initialize a variable of type 'int Str::*' with an rvalue of type 'int *'
    int val = Str::x; //OK
    int* ptr2 = &(Str::x); //Error: undefined reference to 'Str::x'
    return 0;
}

class Str
{
public:
    inline static int x; //内联静态
    int y;

    void fun() {};
};
int main()
{
    int* ptr2 = &(Str::x); //OK
    return 0;
}

– 成员指针的使用：
● 对象 .* 成员指针
● 对象指针 ->* 成员指针

class Str
{
public:
    int x;
    int y;

    void fun() {};
};
int main()
{
    int Str::*ptr = &Str::x;
    Str obj;
    obj.x = 3;
    std::cout << obj.*ptr << std::endl;
    Str* ObjPtr = &obj;
    std::cout << ObjPtr->*ptr << std::endl;
    return 0;
}

在这里插入图片描述

● bind 交互
– 使用 bind + 成员指针构造可调用对象

#include<functional>  //std::bind包含于该头文件中
class Str
{
public:
    int x;
    int y;

    void fun(double x)
    {
        std::cout << x <<std::endl;
    };
};
int main()
{
    auto ptr = &Str::fun;
    Str obj;
    (obj.*ptr)(100.0); //OK
    //(*ptr)(100.0); //Error: Indirection requires pointer operand ('void (Str::*)(double)' invalid)

    //auto x = std::bind(ptr, 100.0); //Error: In template: static_assert failed due to requirement 'integral_constant<bool, false>::value ? sizeof...(_BoundArgs) >= integral_constant<unsigned long long, 1>::value + 1 : sizeof...(_BoundArgs) == integral_constant<unsigned long long, 1>::value + 1' "Wrong number of arguments for pointer-to-member"

    auto y = std::bind(ptr, obj, 100); //OK
    y();
    return 0;
}

在这里插入图片描述

– 注意这种方法也可以基于数据成员指针构造可调用对象

class Str
{
public:
    int x;
    int y;

    void fun(double x)
    {
        std::cout << x <<std::endl;
    };
};
int main()
{
    Str obj;
    auto ptr2 = &Str::x;
    obj.*ptr2 = 3;
    auto x = std::bind(ptr2, obj); //OK
    std::cout << x() << std::endl;
    return 0;
}

在这里插入图片描述

参考
深蓝学院：C++基础与深度解析
C++ Insights

文祐
关注
C++11 标准库 bind 函数
大袖技术
01-04 1056
一、bind 是什么？ bind 顾名思义: 绑定 通俗来讲呢，可以这么理解有点像函数指针的意思。 资料上是这么讲的：可以将 bind 函数看做一个通用函数的适配器，它接受一个可调用对象，生成 一个新的可以调用对象来“适应”原对象参数列表 它一般调用形式： 其中 newCallable 是一个可调用的对象， arg_list 是以逗号分隔的参数列表 这时我们调用 newCallable，newCallable 就会调用 callable， 并用 arg_list 传递参数 auto n
c++中const与constexpr关键字
sky的博客
07-20 1550
const变量的初始化时刻 const修饰变量，表示这个变量是不可修改的，因此const变量必须初始化，一经初始化就不可修改。 如果const变量的初始化值是在编译时就可以确定，则在编译时初始化； 如果const变量的初始化值是在运行时才确定，则在运行时初始化； const int SIZE = 100; 由于SIZE的值是在编译时就已经确定的，编译器会使用常量 100 来替代程序中出现的SIZE。 vector<int> v; const int i = v.s
剑指offer刷题2 空格替换
tiny_Firefly的博客
04-21 4961
问题描述 请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。 要求：时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 32M，其他语言64M 解题思路 为了减少复杂度，字符从后往前移动，首先数出空格数，将末尾的字符依次后移相应的位数，当判断到当前字符时空格时，直接补上%20，进...
C++：基础记录：std::bind用法整理
C++ JAVA的专栏
02-05 607
C++：基础记录：std::bind用法整理
【C++11】—— 包装器
M的博客
01-15 1959
【C++11】—— 包装器。
C++中函数对象模板function＜T＞、通用函数适配器std::bind和lambda
hanxiaoyong_的博客
01-27 1577
C++function用法、C++ std::bind用法、C++ lambda用法、using的使用、std::placeholders::_1用法
C++编程基础知识概述
最新发布
11-01
C++编程基础知识概述 C++是一种强类型、静态编译的通用编程语言，它由Bjarne Stroustrup于1979年在贝尔实验室创建，最初是作为C语言的扩展，后来发展成为一种独立的编程语言。C++以其高效、灵活性和面向对象特性而...
C-C++ 面试基础知识总结_面试C++_C++_
10-02
在准备C++面试时，了解基础的C++概念和技术至关重要。C++是一种强大的、面向对象的编程语言，广泛应用于系统软件、游戏开发、嵌入式系统以及许多高性能应用。以下是对C++面试基础知识的详细总结： 一、C++语言基础 ...
C++基础与提高王桂林
03-09
### C++基础与提高知识点概览 #### 一、C++是什么？ - **C++之父**：Bjarne Stroustrup（本杰·斯特劳斯特鲁普）于1979年开始设计C++。 - **历史背景**：C++是在C语言的基础上发展起来的一种面向对象的编程语言。...
C++基础知识.doc
12-04
C++基础知识 C++基础知识是C++入门者和面试C++工程师岗位前的必备知识点总结。它涵盖了语法语义、STL、排序算法等面试常问的知识点。 一、面向对象的程序设计思想 面向对象的程序设计思想是把数据结构和对数据...
GNU C++ 智能指针20- 解析__shared_ptr类8
kupePoem的专栏
09-19 608
目录 一、关键点解析 1、constexpr （1）概念 （2）constexpr函数 （3）constexpr构造函数 (4)性能测试 二、源码分析 三、参考 一、关键点解析 1、constexpr （1）概念 在 C 里面，const 很明确只有「只读」一个语义，不会混淆。C++ 在此基础上增加了「常量」语义，也由 const 关键字来承担。C++11 把「常量」语义拆出来，交给新引入的 constexpr 关键字。 简单说const其实是r...
Qt5.12+OpenCV4.7.0+Contrib4.7.0编译报错解决方法
FourJin的博客
10-07 1678
解决QT配置opencv编辑问题： error: temporary of non-literal type 'google::protobuf::internal::CallOnceInitializedMutex' in a constant expression constexpr WrappedMutex() {}
c++11的constexpr关键字 literal(常量)
happy_xiahuixiax的博客
04-23 2731
a constant expression is an expression whose value can’t change and that can be evaluated at a compile time. a literal is a constant expression. whether a given object or expression is a constant expr
一篇文章搞懂c语言常量与指针的几个排列组合
zerooffdate的专栏
03-10 6150
这个也是一个比较经典的面试题。也很多人挺纠结的，而且我发现挺多人搞不清楚的。这里先说几个结论，后面在细细验证const int 和 int const是一样的。编译器都认为是int const类型星号，以及星号之后的内容，只修饰右侧的一个变量所以很简单了指向int常量的指针 const int *a , int const * a，都是对的指向int的常量指针int * const a指向int常...
C++11中的std::bind 简单易懂
热门推荐
姜的理想国
07-16 6万+
概述 std::bind的头文件是 <functional>，它是一个函数适配器，接受一个可调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表。 函数原型 std::bind函数有两种函数原型，定义如下： template< class F, class... Args > /*unspecified*/ bind( F&& f, Args&&... args ); template< clas.
C++ literal type
weixin_33862041的博客
03-25 990
要区分 literal 和 literal-type这两个不同的概念。 literal：文字量，10，3.14， true ，u8"123", L"好"这些东西。 literal-type: 参考http://en.cppreference.com/w/cpp/concept/LiteralType 简单的说，就可以在用于编译期运算的对象。 对于标量，例如int，显然可以参与编译期运算，...
C++类属机制与模板基础讲解
本资源是面向对象程序设计基础的课件，主要讲解了第九章的类属机制，包括类属的作用、定义与实例化、继承关系以及类属函数的定义与实例化。类属机制是一种实现编译时多态性的方法，通过参数化数据类型使程序具备多态...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值