相对于java，C++中的那些神奇语法

news2024/12/25 9:24:20

空指针还可以调用成员函数

#include <cstdio>

class Person {
public:
    void sayHello() {
        printf("hello!\n");
    }
};

int main() {
    auto * p = new Person;
    p->sayHello();

    p = nullptr;
    p->sayHello();
    return 0;
}

运行结果如下：

hello!
hello!

进程已结束，退出代码为 0

代码正常运行无异常，函数正常调用正常输出，真是神奇。

需要注意的是，空指针只能调用那些没有使用成员变量的函数，否则就会抛出异常，如下：

class Person {
public:
    int age = 18;
    void sayHello() {
        printf("hello! age = %d\n", age);
    }
};

再次运行代码，结果如下：

hello! age = 18

进程已结束，退出代码为 -1073741819 (0xC0000005)

可以看到，第二次调用sayHello()函数时程序就挂掉了，成员变量还包括this指针，如果是空指针，则this也会是空，所以可以在函数中通过this判断是否是空指针调用，如下：

class Person {
public:
    int age = 18;
    void sayHello() {
        if (this == nullptr) {
            printf("hello!\n");
        } else {
            printf("hello! age = %d\n", age);
        }
    }
};

再次运行，结果如下：

hello! age = 18
hello!

进程已结束，退出代码为 0

经过这样的处理，即便函数中有成员变量，也可以在空指针中正常调用该函数了。

类中的静态成员语法

在这里插入图片描述
如上截图，使用的IDE是CLion，在声明静态变量时不能直接赋值，提示非静态数据成员必须在行外初始化，如下：

class Person {
public:
    static int age;
};

int Person::age = 18;

int main() {
    printf("age = %d\n", Person::age);
    return 0;
}

对于从java转过来学习C的，这语法真的是恶心到我了。

可以直接在文件中声明一个全局静态变量，如下：

class Person {
public:
    static int age;
};

int Person::age = 18;

static int count = 5;

int main() {
    printf("age = %d\n", Person::age);
    return 0;
}

相对而言，类中的静态变量比文件级的静态变量在使用时多了一个类名限定符，且类中的静态变量可以加private等的修饰符。

对于静态函数，函数体可以在类中定义，也可以在类外定义，如下：

class Person {
public:
    static int age;

    static void hello() {
        printf("hello\n");
    }

    static void go();
};

int Person::age = 18;

void Person::go() {
    printf("go go go!");
}


int main() {
    Person::hello();
    Person::go();
    return 0;
}

常函数与mutable成员变量

这个不算奇怪，一种限制成员变量修改的语法，在java中没有，也记录一下：

在函数后面加上const修饰，则在这个函数内不能修改成员变量，如果有某个变量确实需要修改，则在这个变量上加入mutable修饰符，示例如下：

#include <cstdio>

class Person {
public:
    int age = 18;
    mutable int count = 0;

    void fun1() {
        age = 19;
        count = 19;
    }
    void fun2() const {
        //age = 20; // 无法修改
        count = 20; // mutable修饰的变量可以修改
    }
};

int main() {
    Person p;
    p.fun1();
    printf("age = %d, count = %d\n", p.age, p.count);

    p.fun2();
    printf("age = %d, count = %d\n", p.age, p.count);
    return 0;
}

运行结果如下：

age = 19, count = 19
age = 19, count = 20

另外，在创建对象时，在对象类型的前面也可以加入const修饰，修饰后就不可修改成员变量了，但mutable类型的变量可以，在调用函数时，只能调用常函数，示例如下：

class Person {
public:
    int age = 18;
    mutable int count = 0;

    void fun1() {
    }
    void fun2() const {
    }
};

int main() {
    Person p;
    p.age = 45;
    p.count = 45;
    p.fun1();
    p.fun2();

    const Person p2; // 常对象
    //p2.age = 50; // 无法修改
    p2.count = 50; // mutable声明的变量可以赋值
    //p2.fun1();   // 无法调用
    p2.fun2();     // 常函数可以调用
    return 0;
}

友元

全局函数做友元

示例代码如下：

#include <iostream>
using namespace std;

class Home {
public:
    string livingRoom = "客厅";
private:
    string bedroom = "卧室";
};

void visit(const Home &home) {
    cout << "正在访问: " << home.livingRoom << endl;    // 公有成员可以访问
    //cout << "正在访问: " << home.bedroom << endl;     // 私有成员无法访问
}

int main() {
    visit(Home());
    return 0;
}

运行结果如下：

正在访问: 客厅

如上代码，Home类中有一个public类型的livingRoom成员变量，还有一个private类型的bedroom成员变量，visit是一个全局函数，不是Home类的成员函数，所以在visit函数中，不能访问Home对象中的私有成员，就如同现实生活中，客人来了可以访问客厅，但是自己的卧室是比较隐私的，一般不想让客人进入，但是也会有个别的好朋友你是愿意他进入的。代码中也一样，有时候也希望让某些类外的方法也能访问私有的成员，此时可以把这个类外的函数设置为友元，这样它就能访问类中的私有成员了，如下：

#include <iostream>
using namespace std;

class Home {

    // 设置友元
    friend void visit(const Home &home);

public:
    string livingRoom = "客厅";
private:
    string bedroom = "卧室";
};

void visit(const Home &home) {
    cout << "正在访问: " << home.livingRoom << endl;  // 公有成员可以访问
    cout << "正在访问: " << home.bedroom << endl;     // 友元可以访问私有成员
}

int main() {
    visit(Home());
    return 0;
}

运行结果如下：

正在访问: 客厅
正在访问: 卧室

类做友元

#include <iostream>
using namespace std;

class MyFriend;

class Home {

    // 设置友元
    friend void visit(const Home &home);
    friend MyFriend;

public:
    string livingRoom = "客厅";
private:
    string bedroom = "卧室";
};

class MyFriend {
public:
    void visit(const Home &home) {
        cout << "正在访问: " << home.livingRoom << endl;
        cout << "正在访问: " << home.bedroom << endl;
    }
};

void visit(const Home &home) {
    cout << "正在访问: " << home.livingRoom << endl;
    cout << "正在访问: " << home.bedroom << endl;
}

int main() {
    visit(Home());
    MyFriend myFriend;
    myFriend.visit(Home());
    return 0;
}

成员函数做友元

可以设置只允许类中的某个函数做友元，如下：

#include <iostream>

#include <iostream>
using namespace std;

class Home;

class MyFriend {
public:
    void visit(const Home &home);
};

class Home {
    friend void MyFriend::visit(const Home &home);

public:
    string livingRoom = "客厅";
private:
    string bedroom = "卧室";
};

void MyFriend::visit(const Home &home) {
    cout << "正在访问: " << home.livingRoom << endl;
    cout << "正在访问: " << home.bedroom << endl;
}

int main() {
    MyFriend().visit(Home());
    return 0;
}

注意如下代码：

class Home;

class MyFriend {
public:
    void visit(const Home &home);
};

因为Home定义在MyFriend的后面，而在MyFriend中又用到了Home，所以在前面使用class Home声明一下，告诉编译器有Home这个类。

我们把Home和MyFriend的定义换一下位置：

class MyFriend;

class Home {
    friend void MyFriend::visit(const Home &home);

public:
    string livingRoom = "客厅";
private:
    string bedroom = "卧室";
};

class MyFriend {
public:
    void visit(const Home &home);
};

void MyFriend::visit(const Home &home) {
    cout << "正在访问: " << home.livingRoom << endl;
    cout << "正在访问: " << home.bedroom << endl;
}

int main() {
    MyFriend().visit(Home());
    return 0;
}

这个代码是有问题的，无法编译，在CLion中显示错误如下：
在这里插入图片描述
这是因为虽然在前面声明了class MyFriend;，但在Home中使用到了MyFriend的visit函数，这是不行的，因为声明MyFriend只能表明有这样一个类，但是无法知道这个类里面有什么的，于是想到能否把MyFriend的visit函数也声明一下呢？如下：
在这里插入图片描述
如上图，是不是写法有问题，再如下面：
在这里插入图片描述
如上图，还是有问题，那我把visit的定义写到前面呢？如下：
在这里插入图片描述
如上图，也是不行。所以，结论是Home必须定义在MyFriend后面，这奇怪的语法真是令人难记，头痛，怎么记得住谁要定义在谁的前面。再来看正确的代码，如下：

#include <iostream>

#include <iostream>
using namespace std;

class Home;

class MyFriend {
public:
    void visit(const Home &home);
};

class Home {
    friend void MyFriend::visit(const Home &home);

public:
    string livingRoom = "客厅";
private:
    string bedroom = "卧室";
};

void MyFriend::visit(const Home &home) {
    cout << "正在访问: " << home.livingRoom << endl;
    cout << "正在访问: " << home.bedroom << endl;
}

int main() {
    MyFriend().visit(Home());
    return 0;
}

这里visit是定义在类外面的，我们把它定义到类里面，此时就又报错了，如下：

在这里插入图片描述
这是因为Home是定义在MyFriend后面的，所以在MyFriend中无法知道Home中的成员。

后面经过跟公司同事交流，说真实开发中没人会把类都写一个文件，一般是每个类单独写一个头文件和cpp源文件，这样在使用include的时候就不会有这个问题，代码如下：

Home.h如下：

#ifndef WINDOWSAPP_HOME_H
#define WINDOWSAPP_HOME_H

#include "MyFriend.h"
#include <iostream>
using namespace std;

class Home {
    friend void MyFriend::visit(const Home &home);

public:
    string livingRoom = "客厅";
private:
    string bedroom = "卧室";
};

#endif

MyFriend.h如下：

#ifndef WINDOWSAPP_MYFRIEND_H
#define WINDOWSAPP_MYFRIEND_H

class Home;

class MyFriend {
public:
    void visit(const Home & home);
};

#endif

MyFriend.cpp如下：

#include "MyFriend.h"
#include "Home.h"

void MyFriend::visit(const Home & home) {
    cout << "MyFriend正在访问: " << home.livingRoom << endl;
    cout << "MyFriend正在访问: " << home.bedroom << endl;
}

main.cpp如下：

#include "Home.h"
using namespace std;

int main() {
    MyFriend myFriend;
    myFriend.visit(Home());
    return 0;
}

此时运行代码是正常的。

注意，我们在MyFriend.h 中声明了Home类：class Home;，既然都单独写头文件了，为何不直接include呢，于是修改为如下：

#ifndef WINDOWSAPP_MYFRIEND_H
#define WINDOWSAPP_MYFRIEND_H

#include "Home.h"

class MyFriend {
public:
    void visit(const Home & home);
};

#endif

改了这个之后，MyFriend.cpp中就报错了，如下：
在这里插入图片描述
这是因为两个类不能互相包含，详情可看后面的知识

两个对象相互包含

A.h如下：

#pragma once
#include <iostream>
#include "B.h"
class A
{
public:
	B b;
};

B.h如下：

#pragma once
#include <iostream>
#include "A.h"
class B
{
public:
	A a;
};

当我们创建一个A对象的时候，如：A a;由于A里面需要创建一个B，而创建B时又需要创建A，这会导致死循环创建，就如同Java中的如下代码：

public class A {
    public B b = new B();
}

public class B {
    public A a = new A();
}

解决的办法就是不要在声明的时候就直接赋值，修改为如下：

public class A {
    public B b;
}

public class B {
    public A a;
}

后期再给A、B中的成员属性赋值就可以了，C++中也一样，可以把成员变量声明为指针，这样就不会一开始就创建对象了，如下：

A.h如下：

#pragma once
#include <iostream>
#include "B.h"
class A
{
public:
	B * b;
};

B.h如下：

#pragma once
#include <iostream>
#include "A.h"
class B
{
public:
	A * a;
};

这个代码在IDE中是没有报错的，但是运行时会报错，这是因为A和B相互include，虽然前面有#pragma once，还是不行，所以要改为类声明，如下：
A.h如下：

#pragma once
#include <iostream>
class B;
class A
{
public:
	B * b;
};

B.h如下：

#pragma once
#include <iostream>
class A;
class B
{
public:
	A * a;
};

这样就没问题了，main.cpp如下：

#include "A.h"
#include "B.h"

int main()
{
    A a;
    B b;
    a.b = &b;
    b.a = &a;
}

只要不是两个头文件互相包含，也是可以的，比如在A中include B，此时在B中就不能inlclude A了，只能使用class A;来声明一下。一般来说，在头文件里面，能使用类声明，就不要使用include，迫不得已的情况下才使用include，比如，A类在设置B类中的某个方法为友元时就需要使用include，如下：

#pragma once
#include "MyFriend.h"
#include <iostream>
using namespace std;

class Home {
    friend void MyFriend::visit(const Home &home);

public:
    string livingRoom = "客厅";
private:
    string bedroom = "卧室";
};

如上代码，我们在Home中设置MyFriend类的visit(const Home &home)函数为友元函数，以便该函数可以访问Home中的私有变量，所以在Home中，我们需要知道MyFriend类，还需要知道它有一个函数叫visit(const Home &home)，所以需要#include "MyFriend.h"，如果只是使用class MyFriend;来声明一下，这就无法知道MyFriend类中的visit(const Home &home)函数了。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1059.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【深入理解java虚拟机】JVM故障处理工具介绍

【深入理解java虚拟机】JVM故障处理工具介绍

目录前言一、jps&#xff1a;虚拟机进程状况工具一、一 输出远程机器信息二、jstat&#xff1a;虚拟机统计信息监视工具三、jinfo&#xff1a; Java配置信息工具四、jmap&#xff1a; Java内存映像工具五、jhat&#xff1a;虚拟机堆转储快照分析工具六、jstack&#xff1a; Jav…
阅读更多...
问：毁掉一个人，有多容易？答：年龄到了就可以

问：毁掉一个人，有多容易？答：年龄到了就可以

人到中年&#xff0c;有点难。 曾在虎扑论坛上看到一篇爆帖&#xff1a; 标题是《loser回忆录&#xff1a;一年前我月薪两万被人叫X总&#xff0c;如今在美团送外卖》&#xff0c;63万浏览量&#xff0c;回复也超过了2300条。 如题&#xff0c;帖子的主人公是一个35岁的男人…
阅读更多...
node-sass安装失败解决方法

node-sass安装失败解决方法

node-sass安装失败&#xff0c;提示如下&#xff1a; gyp verb check python checking for Python executable "python" in the PATH gyp verb which succeeded python D:Program FilesPython38python.EXE gyp ERR! configure error gyp ERR! stack Error: Command f…
阅读更多...
nvidia显卡驱动、cuda、cudnn、tensorflow对应版本

nvidia显卡驱动、cuda、cudnn、tensorflow对应版本

1、下载显卡驱动 在nvidia官网下载驱动&#xff0c;驱动官网选择设备的驱动进行搜索下载即可&#xff0c;搜索时注意对应的操作系统 一般为安装NVIDIA Studio驱动版本&#xff0c;GeForce Game Ready适用于游戏玩家&#xff0c;下面是两个版本区别的官方解释 下载完的驱动会以…
阅读更多...
关键路径 ← AOE网

关键路径 ← AOE网

【问题描述】 给定一个只有一个源点和一个汇点的有向图&#xff0c;要求求出所有的关键活动&#xff0c;并计算完成该工程至少需要多少时间。【输入格式】 第一行包含两个整数 n 和 m&#xff0c;表示顶点数和边数。 接下来 m 行&#xff0c;每行包含三个整数 u&#xff0c;v&a…
阅读更多...
p2p开户银行审核模块功能实现

p2p开户银行审核模块功能实现

审核模块简介 用户提交开户申请后要等待审核通过才能审核成功 审核需要银行系统进行开户 使用flask框架搭建一个银行系统 用户提交审核 银行进行开户&#xff0c;在返回p2p后台通过审核 flask搭建测试银行系统 利用工厂模式搭建一个flask框架 app.py from flask import Fl…
阅读更多...
程序员必看内容连续集之 Redis 03

程序员必看内容连续集之 Redis 03

目录 一、Spring整合Redis 二、注解式开发 一、Spring整合Redis ①项目的pom文件导入依赖并修改 <redis.version>2.9.0</redis.version> <redis.spring.version>1.7.1.RELEASE</redis.spring.version><dependency><groupId>redis.clien…
阅读更多...
（附源码）计算机毕业设计SSM抗新冠肺炎药品进销存管理系统

（附源码）计算机毕业设计SSM抗新冠肺炎药品进销存管理系统

&#xff08;附源码&#xff09;计算机毕业设计SSM抗新冠肺炎药品进销存管理系统 项目运行 环境配置&#xff1a; Jdk1.8 Tomcat7.0 Mysql HBuilderX&#xff08;Webstorm也行&#xff09; Eclispe&#xff08;IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持&#xff09;。 …
阅读更多...
Synchronized锁的使用

Synchronized锁的使用

前言&#xff1a;大家好&#xff0c;我是小威&#xff0c;24届毕业生&#xff0c;在一家满意的公司实习。本篇文章是关于并发编程中Synchronized锁的用法知识记录&#xff0c;由于篇幅原因&#xff0c;核心原理知识下篇记录。 本篇文章记录的基础知识&#xff0c;适合在学Java的…
阅读更多...
进程的基本概念（操作系统）

进程的基本概念（操作系统）

目录 一、程序的顺序执行及其特征 二、程序的并发执行及其特征 三、进程的特征与状态 1、进程的定义和特征 2、进程的三种基本状态 3、进程的三种基本状态的转换 4、 挂起状态 四、进程控制块&#xff08;PCB&#xff09; 1. PCB作用&#xff1a; PCB是进程存在的唯一…
阅读更多...
【力扣】正则表达式匹配--回溯法解剖

【力扣】正则表达式匹配--回溯法解剖

题目&#xff1a;10.正则表达式匹配 给你一个字符串 s 和一个字符规律 p&#xff0c;请你来实现一个支持 . 和 * 的正则表达式匹配。 . 匹配任意单个字符 * 匹配零个或多个前面的那一个元素 所谓匹配&#xff0c;是要涵盖 整个 字符串 s的&#xff0c;而不是部分字符串。 示…
阅读更多...
maven配置阿里镜像，解决IDEA配置maven恢复默认配置问题

maven配置阿里镜像，解决IDEA配置maven恢复默认配置问题

文章目录1.三个IDEA配置说明2.拷贝与修改settings.xml2.1 找到IDEA的mave配置文件settings.xml位置2.2 拷贝IDEA的settings.xml到.m2目录下2.3 打开settings.xml&#xff0c;配置本地库LocalRepository的路径2.4 删除默认镜像配置&#xff0c;配置阿里镜像2.5 保存文件3.验证是…
阅读更多...
面试时，MySQL这些基础知识你回答的出来吗？

面试时，MySQL这些基础知识你回答的出来吗？

目录 【一】前言 【二】MySQL的并发控制 【三】数据库的事务 【四】隔离级别 【五】死锁 【六】存储引擎 6.1 InnoDB存储引擎 6.2 MyISAM存储引擎 【七】总结 【一】前言 MySQL是一个关系型数据库管理系统&#xff0c;由瑞典MySQL AB公司开发&#xff0c;属于Oracle…
阅读更多...
一文就读懂RPC远程调用核心原理

一文就读懂RPC远程调用核心原理

rpc核心原理 什么是rpc&#xff1f; rpc的全称是Remote Procedure Call&#xff0c;即远程过程调用&#xff0c;是分布式系统的常用通信方法。 Remote&#xff0c;简单来说的话就是两个不同的服务之间&#xff0c;两个服务肯定是两个不同的进程。因此&#xff0c;我们就从跨进…
阅读更多...
【微服务】微服务万字实战，带你了解工程原理

【微服务】微服务万字实战，带你了解工程原理

微服务实战1、前期准备1.1 技术选型1.2 模块设计1.3 微服务调用2、创建父工程3、创建基础模块3.1 导入依赖3.2 创建实体类4、创建用户微服务4.1 创建shop-user模块4.2 用户微服务启动类4.3 创建配置文件5、创建商品微服务5.1 创建shop_product模块5.2 商品微服务启动类5.3 创建…
阅读更多...
刷题日记【第六篇】-笔试必刷题【最近公共祖先+求最大连续bit数+二进制插入+查找组成一个偶数最接近的两个素数】

刷题日记【第六篇】-笔试必刷题【最近公共祖先+求最大连续bit数+二进制插入+查找组成一个偶数最接近的两个素数】

目录 选择题模块 1.下面哪个标识符是合法的&#xff1f;&#xff08;D&#xff09; 2.以下描述正确的是&#xff08;B&#xff09; 3.下列程序的运行结果&#xff08;B&#xff09; 4.下列关于容器集合类的说法正确的是&#xff1f;&#xff08;C&#xff09; 5.ArrayList…
阅读更多...
【MySQL进阶】深入理解InnoDB记录结构

【MySQL进阶】深入理解InnoDB记录结构

【MySQL进阶】深入理解InnoDB记录结构 参考资料&#xff1a;《MySQL是怎么运行的&#xff1a;从根儿上理解MySQL》。 前言&#xff1a; 我们一般使用的MySQL关系型数据库&#xff0c;更是经典中的经典&#xff0c;虽说MySQL已经非常成熟&#xff0c;但对于MySQL的掌握程度&a…
阅读更多...
腾讯Java888道高频面试真题笔记+Java面试宝典

腾讯Java888道高频面试真题笔记+Java面试宝典

这多半年你是否达到了你年初定的目标&#xff0c;今年企业招聘要求也是更加的严格&#xff0c;对于低学历,以及技术实力不过关的更是雪上加霜。也是由于种种缘由&#xff0c;从5月开始就一直有粉丝私信要博主整理一些干货来帮助他们提升下自己&#xff0c;为了响应粉丝要求&…
阅读更多...
Non-Autoregressive Coarse-to-Fine Video Captioning【论文阅读】

Non-Autoregressive Coarse-to-Fine Video Captioning【论文阅读】

Non-Autoregressive Coarse-to-Fine Video Captioning 发表&#xff1a;AAAI 2021idea&#xff1a;&#xff08;1&#xff09;针对推理阶段不能并行&#xff0c;推理效率低的问题使用一种双向解码&#xff08;在bert中不使用sequence mask&#xff09;。&#xff08;2&#xf…
阅读更多...
基于QD求解法的二分类SVM仿真

基于QD求解法的二分类SVM仿真

目录 1.算法概述 2.部分程序 3.算法部分仿真结果图 4.完整程序获取 CSDN用户&#xff1a;我爱C编程 CSDN主页&#xff1a;https://blog.csdn.net/hlayumi1234567?typeblog 擅长技术&#xff1a;智能优化&#xff0c;路径规划&#xff0c;通信信号&#xff0c;图像处理&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023