C++ 嵌套类 （详解 一站式讲解）

于 2025-04-28 23:16:30 发布
阅读量987 收藏 21
点赞数 30
分类专栏： C++ 文章标签： c++ 开发语言 嵌套类 pimpl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74696257/article/details/147597582
版权

目录

嵌套类

嵌套类的定义

嵌套类结构的访问权限

pimpl模式（了解）

嵌套类

嵌套类的定义

首先介绍两个概念：

  • 类作用域（Class Scope）

类作用域是指在类定义内部的范围。在这个作用域内定义的成员（包括变量、函数、类型别名等）可以被该类的所有成员函数访问。类作用域开始于类定义的左花括号，结束于类定义的右花括号。在类作用域内，成员可以相互访问，无论它们在类定义中的声明顺序如何。

  • 类名作用域（Class Name Scope）

类名作用域指的是可以通过类名访问的作用域。这主要用于访问类的静态成员、嵌套类型。类名必须用于访问静态成员或嵌套类型，除非在类的成员函数内部，因为它们不依赖于类的任何特定对象。以静态成员为例：

class MyClass
{
public:
    void func(){
        _b = 100;//类的成员函数内访问_b
    }
    static int _a;
    int _b;
};
//静态成员要定义在类外，因为静态成员是一个类所共有的，如果声明在类中，每创建一个类对象就会生成一个静态数据成员
int MyClass::_a = 0;

void test0(){
    //这里静态数据成员为公有所以可以在类外通过类名直接访问
    MyClass::_a = 200;//类外部访问_a
}

在函数和其他类定义的外部定义的类称为全局类，绝大多数的 C++ 类都是全局类。我们在前面定义的所有类都在全局作用域中，全局类具有全局作用域。

与之对应的，一个类A还可以定义在另一类B的定义中，这就是嵌套类结构。A类被称为B类的内部类，B类被称为A类的外部类。

以Point类和Line类为例

class Line
{
public:
    class Point{
    public:
        Point(int x,int y)
        : _ix(x)
        , _iy(y)
        {}
    private:
        int _ix;
        int _iy;
    };
public:
    Line(int x1, int y1, int x2, int y2)
    : _pt1(x1,y1)
    , _pt2(x2,y2)
    {}
private: 
    Point _pt1;
    Point _pt2;
};

Point类是定义在Line类中的内部类，无法直接创建Point对象，需要在Line类名作用域中才能创建，因为point类在line类中，只能先找到line类在访问point类

Point pt(1,2);//error
Line::Point pt2(3,4);//ok

Point类是Line类的内部类，并不代表Point类的数据成员会占据Line类对象的内存空间，在存储关系上并不是嵌套的结构。

只有当Line类有Point类类型的对象成员时，Line类对象的内存布局中才会包含Point类对象（成员子对象）。

（1）如果Line类中没有Point类的对象成员，sizeof(Line) = 8;

（2）如果Line类中有两个Point类的对象成员，sizeof(Line) = 24;

思考，如果想要使用输出流运算符输出Line对象，应该怎么实现？（重要）

最直观的实现方式是定义一个运算符重载函数，但在函数体中需要让输出流运算符处理Point类型对象，所以还需要为Point类准备一个输出流运算符重载函数。

—— 如果Point定义在Line的私有区域

那么还需要将operator<<函数声明为Line的友元函数

下面为测试代码，可自行测试

#include <iostream>
using namespace std;
class Line
{
public:
    class Point {
    public:
        Point(int x, int y)
            : _ix(x)
            , _iy(y)
        {}
        friend ostream& operator<<(ostream& os, const Line::Point& rhs);
    private:
        int _ix;
        int _iy;
    };
public:
    Line(int x1, int y1, int x2, int y2)
        : _pt1(x1, y1)
        , _pt2(x2, y2)
    {}
    ~Line() {
        //cout << "~Line（）" << endl;
    }
    friend ostream& operator<<(ostream& os, const Line& rhs);
    friend ostream& operator<<(ostream& os, const Point& rhs);
    
private:
    Point _pt1;
    Point _pt2;
};

//这里会访问line的私有成员point所以在line类中声明为友元,因为又要访问point对象的数据成员，
//所以又要将这个函数声明为内部类的友元
ostream& operator<<(ostream& os, const Line::Point& rhs)
{
    os << "(" << rhs._ix << "," << rhs._iy << ")";
    return os;
}


//因为是输出运算符重载，不会对操作数进行修改，倾向于声明为有友元类
ostream& operator<<(ostream & os, const Line & rhs)
{
    os << rhs._pt1 << "------->" << rhs._pt2;
    return os;
}
void test()
{
    Line ll(1, 2, 3, 4);
    cout << ll << endl;
}
int main()
{
    test();
    return 0;
}

嵌套类结构的访问权限

外部类对内部类的成员进行访问

内部类对外部类的成员进行访问

image-20240304153639911

内部类相当于是定义在外部类中的外部类的友元类

类A定义在类B中，那么类A访问类B的成员时，就相当于默认的是类B的友元类。

下面为测试代码，可以自行测试

#include <iostream>
using namespace std;
class Line
{
public:
    class Point {
    public:
        Point(int x, int y)
            : _ix(x)
            , _iy(y)
        {}
        friend ostream& operator<<(ostream& os, const Line::Point& rhs);
        void print()
        {
            cout << "print" << endl;
        }
        friend class Line;
        void getline(const Line& rhs)
        {
            //在内部类中不需要友元声明，可以直接通过line对象直接访问成员
            rhs._pt1;
            rhs._pt2;
            //通过类名作用域直接访问line的私有静态成员
            Line::_pt3;
            //直接用成员名访问line的私有静态数据成员
            _pt3;
        }
    private:
        int _ix;
        int _iy;
        static int _iz;
    };
public:
    Line(int x1, int y1, int x2, int y2)
        : _pt1(x1, y1)
        , _pt2(x2, y2)
    {}
    ~Line() {
        //cout << "~Line（）" << endl;
    }
    friend ostream& operator<<(ostream& os, const Line& rhs);
    friend ostream& operator<<(ostream& os, const Point& rhs);
    void getpoint()
    {
        //在外部类中通过内部类访问内部类的公有成员
        _pt1.print();//ok
        //外部类属于内部类的类定义之外，这里是在内部类的私有数据成员
        //在外部类中通过内部类对象访问内部类的私有成员
        //_pt1._ix;//需要声明友元
        Point::_iz;//因为为私有，所以需要友元声明
        
        //_ix;不可能实现
        //_iy;同上
    }
private:
    Point _pt1;
    Point _pt2;
    static double _pt3;
};
//要在外部类的外面对内部类的静态成员进行定义
int Line::Point::_iz = 10;
double Line::_pt3 = 100;
//这里会访问line的私有成员point所以在line类中声明为友元,因为又要访问point对象的数据成员，
//所以又要将这个函数声明为内部类的友元
ostream& operator<<(ostream& os, const Line::Point& rhs)
{
    os << "(" << rhs._ix << "," << rhs._iy << ")";
    return os;
}


//因为是输出运算符重载，不会对操作数进行修改，倾向于声明为有友元类
ostream& operator<<(ostream & os, const Line & rhs)
{
    os << rhs._pt1 << "------->" << rhs._pt2;
    return os;
}
void test()
{
    Line ll(1, 2, 3, 4);
    cout << ll << endl;
}
int main()
{
    test();
    return 0;
}

pimpl模式（了解）

实际项目的需求：希望Line的实现全部隐藏，在源文件中实现，再将其打包成库文件，交给第三方使用。

（1）头文件只给出接口：

//Line.hpp
class Line{
public:
    Line(int x1, int y1, int x2, int y2);
    ~Line();
    void printLine() const;//打印Line对象的信息
private:
    class LineImpl;//类的前向声明
    LineImpl * _pimpl;
};

（2）在实现文件中进行具体实现，使用嵌套类的结构（LineImpl是Line的内部类，Point是LineImpl的内部类），Line类对外公布的接口都是使用LineImpl进行具体实现的

在测试文件中创建Line对象（最外层），使用Line对外提供的接口，但是不知道具体的实现

//LineImpl.cc
class Line::LineImpl
{
    class Point{
    public:
        Point(int x,int y)
            : _ix(x)
              , _iy(y)
        {}
		//...
    private:
        int _ix;
        int _iy;
    };
    //...
};

//Line.cc
void test0(){
    Line line(10,20,30,40);
    line.printLine();
}

（3）打包库文件，将库文件和头文件交给第三方

sudo apt install build-essential
g++ -c LineImpl.cc
ar rcs libLine.a LineImpl.o

生成libLine.a库文件
编译：g++ Line.cc(测试文件) -L(加上库文件地址) -lLine(就是库文件名中的lib缩写为l，不带后缀)
此时的编译指令为 g++ Line.cc -L. -lLine

内存结构

pimpl模式是一种减少代码依赖和编译时间的C++编程技巧，其基本思想是将一个外部可见类的实现细节（一般是通过私有的非虚成员）放在一个单独的实现类中，在可见类中通过一个私有指针来间接访问该类型。

好处：

  1. 实现信息隐藏；

  2. 只要头文件中的接口不变，实现文件可以随意修改，修改完毕只需要将新生成的库文件交给第三方即可；

  3. 可以实现库的平滑升级。

下面为测试代码，可自行测试

//LineImpl.cc

#include <iostream>
#include "Line.hpp"
using namespace std;
// 这是一个实现文件，不用包含测试，只需要实现头文件中的函数等内容
//先对成员类型进行实现
class Line::LineImpl
{
public:
    class Point{
    public:
        Point(int x,int y)
        : _ix(x)
        , _iy(y)
        {}
        ~Point()
        {
            cout << "~Point()" << endl;
        }
        void print()
        {
            cout << "("<<_ix << "," 
                << _iy << ")";
        }
    private:
        int _ix;
        int _iy;
    };
public:
    LineImpl(int x1, int y1, int x2, int y2)
    : _pt1(x1,y1)
    , _pt2(x2,y2)
    {
        cout << "LineImpl(int *4)" << endl;
    }
    ~LineImpl()
    {
        cout << "~LineImpl()" << endl;
    }
    void printline()
    {
        _pt1.print();
        cout << "-----> ";
        _pt2.print();
        cout << endl;
    }
private: 
    Point _pt1;
    Point _pt2;
};

Line::Line(int x1, int y1, int x2, int y2)
    :_pimpl(new LineImpl(x1,y1, x2,y2))
{
    cout << "Line(int * 4)" << endl;
}
Line :: ~Line()
{
    cout << "~Line()" << endl;
    if(_pimpl)
    {
        delete _pimpl;
        _pimpl = nullptr;
    }
}
void Line::printLine() const{
    _pimpl->printline();
}

// test.cc

#include "Line.hpp"
#include <iostream>
using std::cout;
using std::endl;

void test()
{
    Line ll(1,2,3,4);
    ll.printLine();
}

int main()
{
    test();
    return 0;
}

//Line.hpp

#ifndef _Line_HPP_
#define _Line_HPP_

class Line {
public:
    Line(int x1, int y1, int x2, int y2);
    ~Line();
    //提供给客户使用的功能
    void printLine() const;//打印Line对象的信息
private:
    class LineImpl;//类的前向声明
    LineImpl* _pimpl;
};

#endif

C++嵌套类
weixin_50866517的博客
04-20 4032
嵌套类介绍二级目录三级目录 介绍 在c++中，可以将类的声明放在另一个类中。在另一个类中声明的类被称为嵌套类，它通过提供新的类型类作用域来避免混乱。包含类的成员函数可以创建和使用被嵌套类的对象；而仅当声明位于公有部分，才能在包含类的外面使用嵌套类，而且必须使用作用域解析运算符。 对类进行嵌套与包含并不不同。包含意味着将类对象作为另一个类的成员，而对类进行嵌套不创建类成员，而是定义了一种类型，该类型仅在包含嵌套类声明的类中有效。 对类进行嵌套通常是为了帮助实现另一个类，并避免名称冲突。Queue类示例嵌套了结
【逆向工程】C/C++的反汇编表示详解（1）函数调用，栈平衡，变量与参数的内存布局
L2510408497的博客
07-06 4349
很多人学完汇编，去看C/C++的反汇编就会很懵，发现单独看一条指令看的明明白白，但连在多条指令连在一起就不知道有什么作用了，如 push ebp mov ebp,esp sub esp,40h lea edi,[ebp-40h] mov ecx,10h mov eax,0CCCCCCCCh rep stos dword ptr [edi] 这里用VC6.0是最好的，更能看出本质，VS系列也可以，VS的话
类的嵌套
weixin_34128839的博客
01-28 131
class1.h文件中： #ifndef CLASS1_H_ #define CLASS1_H_ #include <iostream> #include <string> class class1 { public: class class2 { public: class2(); class2(const class2 & s...
【C++】 嵌套类（Nested Class）
最新发布
cxyhjl的博客
03-11 524
嵌套类是在外部类的类体内部定义的类。public:public:// 嵌套类的功能实现在这个例子中，Nested是定义在Outer类内部的嵌套类。嵌套类可以在外部类中声明，然后在外部类外定义。public:// 前置声明public:// 定义嵌套类的功能这种方式可以分离声明和实现，提高代码的可读性。嵌套类是 C++ 中一种强大的工具，用于组织和封装代码。它允许在类的内部定义其他类，从而提高代码的模块化和可维护性。理解嵌套类的访问控制、作用域和实例化规则对于正确使用它们至关重要。
类与类的嵌套
taw19960426的博客
06-26 281
package 测试标识符; class Computer{// 放前面，电脑类型 String brand; } public class Student { //void play() ; int age; String name; int xuehao; Computer comp;// 取名字 public static void main(String[] ar...
c++——类的嵌套
afootball的博客
12-22 4431
c++类的嵌套模板 1.作用域 如果一个嵌套类在另一个类的私有部分声明的，嵌套类对于这个类是可见的，对于外界是不可见的。 如果一个嵌套类在另一个类的公有部分声明的，则允许在这个类和外界使用这个嵌套类。 2.访问权限 嵌套类的私有部分不允许在声明嵌套类中的这个类访问 queuetp.h类的初始 #ifndef _QUEUETP_H_ #define _QUEUETP_H_ #include <iostream> using std::string; using std::cin; us
嵌套类
友善啊，朋友的博客
03-02 547
#define debug qDebug()<< class outside { public: explicit outside(int f,int s):frist{f},second{s} { } void debugValue() { debug four; debug frist; debug second; } static int four; private: int.
.NET+C++编码规范详解：一站式参考与实践
".NET+编码规范"是一份由葛佳亮和蒋里京合作编写的文档，旨在提供微软一站式代码示例库项目组采用的编程风格指南，覆盖C++和.NET语言（包括C#和VB.NET）。这份文档强调了遵循一套统一的编码标准，以提升代码质量、...
微软一站式代码库编程规范详解
"微软一站式示例代码库编程规范" 本文档详细阐述了微软的编程规范，旨在为开发者提供一套全面的指导原则，以提高代码质量、可读性和维护性。这份规范不仅涵盖了通用的编程准则，还特别针对C++语言提出了具体要求。 ...
微软一站式示例代码库编程规范详解
“一站式示例代码库编程规范中文版”是一份详细指导.NET开发者遵循的编程准则，涵盖了通用编程规范和C++特定的编程规范。该规范由微软内部专家和团队成员共同编纂，旨在提高代码质量和一致性。 1. **概览** - 原则...
微软一站式编码标准（中文版）
06-08
### 微软一站式编码标准（中文版）知识点详解 #### 一、概览 本文档主要介绍了微软一站式代码示例库项目组所采用的本地C++及.NET（C#和VB.NET）编程风格指导规范。该规范旨在为社区开发者提供一套高效、减少错误并...
类嵌套的问题和解决办法
07-16
介绍了类嵌套中常出现的问题 指出了问题出现的原因 以及解决办法 本文中介绍了用类指针来解决类嵌套的问题的方法 还有类声明和类包含的用法区别 最后提出了在编程中应注意的几点问题 可以很好的预防类嵌套的问题
嵌套类型
qq_17190231的博客
07-10 343
struct BlackJackCard { enum Suit: Character { case spades = “♠”, hearts = “♡”, diamonds = “♢”, clubs = “♣” } enum Rank: Int { case two = 2, three, four, five, six, seven, eight, night, ten cas...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值