【C++】3.类和对象（1）

于 2024-08-06 23:10:55 发布
阅读量493 收藏 22
点赞数 24
分类专栏： C++学习2 文章标签： c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hlyd520/article/details/140968381
版权

文章目录

1.类的定义

1.1 类定义格式

  • class为定义类的关键字，Stack为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略。类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的方法或者成员函数。

  • 为了区分成员变量，一般习惯上成员变量会加一个特殊标识，如成员变量前面或者后面加_ 或者 m开头，注意C++中这个并不是强制的，只是一些惯例，具体看公司的要求。

  • C++中struct也可以定义类，C++兼容C中struct的用法，同时struct升级成了类，明显的变化是struct中可以定义函数，一般情况下我们还是推荐用class定义类。

  • 定义在类面的成员函数默认为inline。

class Date
{
public://公共区域，可以在类外面访问
    void Init(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
private://私有区域，不可以在类外面访问，可以在类的里面访问
    // 为了区分成员变量，一般习惯上成员变量
    // 会加一个特殊标识，如_ 或者 m开头
    int _year; // year_ / m_year
    int _month;
    int _day;
};

int main()
{
    Date d;
    d.Init(2024, 3, 31);
    return 0;
}

#include<iostream>
using namespace std;
// C++升级struct升级成了类
// 1、类里面可以定义函数
// 2、struct名称就可以代表类型
// C++兼容C中struct的用法
typedef struct ListNodeC
{
    struct ListNodeC* next;
    int val;
}LTNode;

// 不再需要typedef，ListNodeCPP就可以代表类型
struct ListNodeCPP
{
    void Init(int x)
    {
        next = nullptr;
        val = x;
    }
    ListNodeCPP* next;
    int val;
};

int main()
{
    return 0;
}

1.2 访问限定符

  • C++一种实现封装的方式，用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用。

  • public修饰的成员在类外可以直接被访问；protected和private修饰的成员在类外不能直接被访问，protected和private是一样的，以后继承章节才能体现出他们的区别。

  • 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止，如果后面没有访问限定符，作用域就到 }即类结束。

  • class定义成员没有被访问限定符修饰时默认为private，struct默认为public。

  • 一般成员变量都会被限制为private/protected，需要给别人使用的成员函数会放为public。

6109b8f05b08aa76cce94855765a87ac

【面试题】

问题：C++中struct和class的区别是什么？

解答：C++需要兼容C语言，所以C++中struct可以当成结构体使用。另外C++中struct还可以用来定义类。和class定义类是一样的，区别是struct定义的类默认访问权限是public，class定义的类默认访问权限是private。注意：在继承和模板参数列表位置，struct和class也有区别，后序介绍。

1.3 类域

  • 类定义了一个新的作用域：类域。

  • 类的所有成员都在类的作用域中，在类体外定义成员时，需要使用 :: 作用域操作符指明成员属于哪个类域。

  • 类域影响的是编译的查找规则，下面程序中Init如果不指定类域Stack，那么编译器就把Init当成全局函数，那么编译时，找不到array等成员的声明/定义在哪里，就会报错。

    指定类域Stack，就是知道Init是成员函数，当前域找不到的array等成员，就会到类域中去查找。

#include<iostream>
using namespace std;

class Stack
{
public:
    // 成员函数
    void Init(int n = 4);
private:
    // 成员变量
    int* array;
    size_t capacity;
    size_t top;
};
// 声明和定义分离，需要指定类域
void Stack::Init(int n)
{
    array = (int*)malloc(sizeof(int) * n);
    if (nullptr == array)
    {
        perror("malloc申请空间失败");
        return;
    }
    capacity = n;
    top = 0;
}

int main()
{
    Stack st;
    st.Init();
    return 0;
}

#include<iostream>
using namespace std;

class Q
{
public:
    void Init(int n = 4) {
        cout << "Q" << endl;
    }
};

class Stack
{
public:
    // 成员函数
    void Init(int n = 4);
private:
    // 成员变量
    int* array;
    size_t capacity;
    size_t top;
};

void Init(int n = 4) {
    cout << "1" << endl;
}
// 声明和定义分离，需要指定类域
void Stack::Init(int n)
{
    cout << "Stack" << endl;
}

int main()
{
    Q st1;
    st1.Init();//Q
    Stack st;
    st.Init();//Stack
    Init();//1
    return 0;
}

2.实例化

2.1 实例化概念

  • 用类类型在物理内存中创建对象的过程，称为类实例化出对象。

  • 类是对象进行一种抽象描述，是一个模型一样的东西，限定了类有哪些成员变量，这些成员变量只是声明，没有分配空间，用类实例化出对象时，才会分配空间。

  • 一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量。打个比方：类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，设计图规划了有多少个房间，房间大小功能等，但是并没有实体的建筑存在，也不能住人，用设计图修建出房子，房子才能住人。同样类就像设计图一样，不能存储数据，实例化出的对象分配物理内存存储数据。

4844fccf7520bba9a59a4d6035c7431b

#include<iostream>
using namespace std;

class Date
{
public:
    void Init(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    void Print()
    {
        cout << _year << "/" << _month << "/" << _day << endl;
    }
private:
    // 这里只是声明，没有开空间
    int _year;
    int _month;
    int _day;
};

int main()
{
    Date d1;// Date类实例化出对象d1
    Date d2;// Date类实例化出对象d2
    d1.Init(2024, 3, 31);
    d1.Print();//2024/3/31
    d2.Init(2024, 7, 5);
    d2.Print();//2024/7/5
    
    // 对象中只存储的成员变量，没有存储成员函数
	cout << sizeof(d1) << endl;//12
	cout << sizeof(d2) << endl;//12
    
    return 0;
}

2.2 对象大小

分析一下类对象中哪些成员呢？

类实例化出的每个对象，都有独立的数据空间，所以对象中肯定包含成员变量，那么成员函数是否包含呢？

首先函数被编译后是一段指令，对象中没办法存储，这些指令存储在一个单独的区域(代码段)，那么对象中非要存储的话，只能是成员函数的指针。再分析一下，对象中是否有存储指针的必要呢，Date实例化d1和d2两个对象，d1和d2都有各自独立的成员变量_year/_month/_day存储各自的数据，但是d1和d2的成员函数Init/Print指针却是一样的，存储在对象中就浪费了。如果用Date实例化100个对象，那么成员函数指针就重复存储100次，太浪费了。这里需要再额外哆嗦一下，其实函数指针是不需要存储的，函数指针是一个地址，调用函数被编译成汇编指令[call 地址]， 其实编译器在编译链接时，就要找到函数的地址，不是在运行时找，只有动态多态是在运行时找，就需要存储函数地址，这个我们以后会讲解。

a10b8a4ef5dde7677f0865548a63c2ef
6183f1106fbc35b950c47033598ab50a
84804ca5d115d15e9a53618a6042e698

上面我们分析了对象中只存储成员变量，C++规定类实例化的对象也要符合内存对齐的规则。

内存对齐规则：

  • 第一个成员在与结构体偏移量为0的地址处。

  • 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。

  • 注意：对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。

  • VS中默认的对齐数为8

  • 结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。

  • 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

#include<iostream>
using namespace std;
// 计算一下A/B/C实例化的对象是多大？
class A
{
public:
    void Print()
    {
        cout << _ch << endl;
    }
private:
    char _ch;
    int _i;
};

class B
{
    public:
    void Print()
    {
        //...
    }
};

class C
{};

int main()
{
    A a;
    B b;
    C c;
    //_ch=1;_int=4;最大对齐数8
    cout << sizeof(a) << endl;//8 
    
    cout << sizeof(b) << endl;//1
    cout << sizeof(c) << endl;//1
    return 0;
}

上面的程序运行后，我们看到没有成员变量的B和C类对象的大小是1，为什么没有成员变量还要给1个字节呢？因为如果一个字节都不给，怎么表示对象存在过呢？所以这里给1字节，纯粹是为了占位标识对象存在。

3.this指针

  • Date类中有 Init 与 Print 两个成员函数，函数体中没有关于不同对象的区分，那当d1调用Init和Print函数时，该函数是如何知道应该访问的是d1对象还是d2对象呢？那么这里就要看到C++给了一个隐含的this指针解决这里的问题

  • 编译器编译后，类的成员函数默认都会在形参第一个位置，增加一个当前类类型的指针，叫做this指针。比如Date类的Init的真实原型为， void Init(Date* const this, int year, int month, int day)

  • 类的成员函数中访问成员变量，本质都是通过this指针访问的，如Init函数中给_year赋值， this->_year = year;

  • C++规定不能在实参和形参的位置显示的写this指针(编译时编译器会处理)，但是可以在函数体内显示使用this指针。

class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	// d1.Print();
	// d2.Print();
	void Print()
	{
		cout << this->_year << "-" << _month << "-" << _day << endl;
	}
    
	/*void Print(Date* const this1)
	{
		cout << this->_year << "-" << this->_month << "-" << this->_day << endl;
	}*/
	

//private:
	int _year;     // 年   声明
	int _month;    // 月
	int _day;      // 日
};

int main()
{
	Date d1, d2;
	d1.Init(2022, 1, 11);
	d2.Init(2022, 1, 12);
	d1.Print();
	//000000FEB5F5F708
	//2022 - 1 - 11
	d2.Print();
	//000000FEB5F5F738
	//2022 - 1 - 12

	//Date::_year;//错误！上面是声明，没有你所需要的空间
	//d1._year;//错误！这个是域作用限定符。这里的左边的d1不是域。对象里面访问只能是.

    
	//下面两行会报错，想要使用的话要把void Print()变成void Print(Date* const this1)，并且把d1.Print();和d2.Print();注释掉
    //或者直接把注释掉的void Print(Date* const this1)给恢复然后就会打印
	
	//this指向&d1
	d1.Print(&d1);//2022 - 1 - 11
	//this指向&d2
	d2.Print(&d2);//2022 - 1 - 12

    return 0;
}

void Print()
{
	// this不能在形参和实参显示传递，但是可以在函数内部显示使用
	//this = nullptr;//不可以哦
	cout << this << endl;
	cout << this->_year << "-" << _month << "-" << _day << endl;
}

// 编译器会成员函数的处理
void Print(Date* const this)
{
	cout << this->_year << "-" << this->_month << "-" << this->_day << endl;
}

对于上述类，有这样的一个问题：

Date类中有 Init 与 Print 两个成员函数，函数体中没有关于不同对象的区分，那当d1调用 Init 函数时，该函数是如何知道应该设置d1对象，而不是设置d2对象呢？

C++中通过引入this指针解决该问题，即：C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量”的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

this指针存在哪里？对象，栈，堆，静态区，常量区？

this是形参，所以this指针是跟普通参数一样存在函数调用的栈帧里面，函数调用结束，this就销毁了vs下面对this指针传递进行了优化，对象地址是放在ecx里面的，ecx存储this指针的值

this指针的特性

  1. this指针的类型：类类型* const，即成员函数中，不能给this指针赋值。
  2. 只能在“成员函数”的内部使用
  3. this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
  4. this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递

【面试题】

  1. this指针存在哪里？

this指针是一个隐含的指针，存在于每个非静态成员函数中。它指向调用该成员函数的对象本身。this 指针是编译器在编译时自动添加的，用于访问对象的成员变量和成员函数。它并不占用对象本身的内存空间，而是作为一个隐含的参数传递给成员函数。

  1. this指针可以为空吗？

不可以

下面通过两个选择题测试一下前面的知识学得如何？

1.下面程序编译运行结果是（）

A、编译报错 B、运行崩溃 C、正常运行

#include<iostream>
using namespace std;

class A
{
public:
    void Print()//p是一个实参，把p这个空指针传递给形参没有问题，因为这里没有解引用
    {
        cout << "A::Print()" << endl;
    }
private:
    int _a;
};

int main()
{
    A* p = nullptr;//p是一个空指针
    //成员函数的指针是在编译时确定的，没有存在对象中，所以这里虽然写了p->，但是没有解引用
    p->Print();
    return 0;
}

答案：C

2.下面程序编译运行结果是（）

A、编译报错 B、运行崩溃 C、正常运行

#include<iostream>
using namespace std;

class A
{
public:
    void Print()//p是一个实参，把p这个空指针传递给形参没有问题，但是这里解引用了
    {
        cout << "A::Print()" << endl;
        cout << _a << endl;//这里实际上是cout << this->_a << endl;因为this是空指针，所以这里就运行崩溃了
    }
private:
    int _a;
};

int main()
{
    A* p = nullptr;//p是一个空指针
    //成员函数的指针是在编译时确定的，没有存在对象中，所以这里虽然写了p->，但是没有解引用
    p->Print();
    return 0;
}

答案：B

3.this指针存在内存哪个区域的 ()

A. 栈 B.堆 C.静态区 D.常量区 E.对象里面

答案：A

4.C++和C语言实现Stack对比

面向对象三大特性：封装、继承、多态，下面的对比我们可以初步了解一下封装。

通过下面两份代码对比，我们发现C++实现Stack形态上还是发生了挺多的变化，底层和逻辑上没啥变化。

  • C++中数据和函数都放到了类里面，通过访问限定符进行了限制，不能再随意通过对象直接修改数据，这是C++封装的一种体现，这个是最重要的变化。这里的封装的本质是一种更严格规范的管理，避免出现乱访问修改的问题。当然封装不仅仅是这样的，我们后面还需要不断的去学习。

  • C++中有一些相对方便的语法，比如Init给的缺省参数会方便很多，成员函数每次不需要传对象地址，因为this指针隐含的传递了，方便了很多，使用类型不再需要typedef用类名就很方便

  • 在我们这个C++入门阶段实现的Stack看起来变了很多，但是实质上变化不大。后面看STL中的用适配器实现的Stack，会让我们感受到C++的魅力。

C实现Stack代码

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
typedef int STDataType;
typedef struct Stack
{
    STDataType* a;
    int top;
    int capacity;
}ST;
void STInit(ST* ps)
{
    assert(ps);
    ps->a = NULL;
    ps->top = 0;
    ps->capacity = 0;
}
void STDestroy(ST* ps)
{
    assert(ps);
    free(ps->a);
    ps->a = NULL;
    ps->top = ps->capacity = 0;
}
void STPush(ST* ps, STDataType x)
{
    assert(ps);
    // 满了， 扩容​
    if (ps->top == ps->capacity)
    {
        int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
        STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * 
                                               sizeof(STDataType));
        if (tmp == NULL)
        {
            perror("realloc fail");
            return;
        }
        ps->a = tmp;
        ps->capacity = newcapacity;
    }
    ps->a[ps->top] = x;
    ps->top++;
}
bool STEmpty(ST* ps)
{
    assert(ps);
    return ps->top == 0;
}
void STPop(ST* ps)
{
    assert(ps);
    assert(!STEmpty(ps));
    ps->top--;
}
STDataType STTop(ST* ps)
{
    assert(ps);
    assert(!STEmpty(ps));
    return ps->a[ps->top - 1];
}
int STSize(ST* ps)
{
    assert(ps);
    return ps->top;
}
int main()
{
    ST s;
    STInit(&s);
    STPush(&s, 1);
    STPush(&s, 2);
    STPush(&s, 3);
    STPush(&s, 4);
    while (!STEmpty(&s))
    {
        printf("%d\n", STTop(&s));
        STPop(&s);
    }
    STDestroy(&s);
    return 0;
}

可以看到，在用C语言实现时，Stack相关操作函数有以下共性：

  1. 每个函数的第一个参数都是Stack*

  2. 函数中必须要对第一个参数检测，因为该参数可能会为NULL

  3. 函数中都是通过Stack*参数操作栈的

  4. 调用时必须传递Stack结构体变量的地址

结构体中只能定义存放数据的结构，操作数据的方法不能放在结构体中，即数据和操作数据的方式是分离开的，而且实现上相当复杂一点，涉及到大量指针操作，稍不注意可能就会出错。

C++实现Stack代码

#include<iostream>
using namespace std;

typedef int STDataType;

class Stack
{
public:
    // 成员函数
    void Init(int n = 4)
    {
        _a = (STDataType*)malloc(sizeof(STDataType) * n);
        if (nullptr == _a)
        {
            perror("malloc申请空间失败");
            return;
        }
        _capacity = n;
        _top = 0;
    }
    void Push(STDataType x)
    {
        if (_top == _capacity)
        {
            int newcapacity = _capacity * 2;
            STDataType* tmp = (STDataType*)realloc(_a, newcapacity * 
                                                   sizeof(STDataType));
            if (tmp == NULL)
            {
                perror("realloc fail");
                return;
            }
            _a = tmp;
            _capacity = newcapacity;
        }
        _a[_top++] = x;
    }
    void Pop()
    {
        assert(_top > 0);
        --_top;
    }
    bool Empty()
    {
        return _top == 0;
    }
    int Top()
    {
        assert(_top > 0);
        return _a[_top - 1];
    }
    void Destroy()
    {
        free(_a);
        _a = nullptr;
        _top = _capacity = 0;
    }
private:
    // 成员变量
    STDataType* _a;
    size_t _capacity;
    size_t _top;
};

int main()
{
    Stack s;
    s.Init();
    s.Push(1);
    s.Push(2);
    s.Push(3);
    s.Push(4);
    while (!s.Empty())
    {
        printf("%d\n", s.Top());
        s.Pop();
    }
    s.Destroy();
    return 0;
}

C++中通过类可以将数据 以及 操作数据的方法进行完美结合，通过访问权限可以控制那些方法在类外可以被调用，即封装，在使用时就像使用自己的成员一样，更符合人类对一件事物的认知。而且每个方法不需要传递Stack*的参数了，编译器编译之后该参数会自动还原，即C++中 Stack *参数是编译器维护的，C语言中需用用户自己维护。

流星白龙
关注
  • 24
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
C++对象内存模型.pdf
04-18
本文讨论了 C++ 对象内存模型的基本概念和结构，并通过实验和分析来探索对象内存结构、简单类型相关数据、包含虚函数类的对象内存结构、继承下的多态性等问题。理解 C++ 对象内存模型对于 C++ 编程语言的学习和应用...
C++实验一-类与简单对象.doc
11-15
7. 面向对象程序设计的基本思想、基本方法和基本步骤：面向对象程序设计是基于对象和类的程序设计思想，强调模块化、抽象化和继承性。 8. MS Visual C++6.0 或 DEV C++调试 C++程序的基本方法、基本步骤：调试 C++...
C++类和对象详细总结
m0_56910081的博客
04-11 1万+
类与对象概念 什么是对象 对象是一个实体，我们眼睛看到的所有实体都可以看成一个实体对象 什么是类 类是用来对实体（对象）进行描述的。（对象有什么属性，有什么功能）类是一种自定义类型 什么是方法： 方法是实现类功能的一个具体实现，该类有什么样的功能？类的所有功能都要通过调用方法来实现。 自定义类型（类的关键字：class） C中我们学过struct（结构体）自定义类型。c++为了兼容c语言，在这里我们也可以使用struct来定义类。和c不同的是，c++中的struct可以在内部放置函数，除此以
C++的类和对象
Cosmicsea的博客
05-21 5204
C++面向对象的三大特性：封装、继承、多态 C++认为万事万物皆可为对象，对象有其属性和行为 具有相同性质的对象，可以抽象为类 封装 类在设计时，可以把属性和行为放在不同的权限下，加以控制 public：公共权限，类内可访问、类外可访问， protected：保护权限，类内可访问、类外不可访问，儿子可以访问父亲的保护内容 private：私有权限，类内可访问、类外不可访问，儿子不可以访问父亲的私有内容 struct和class的区别在于 struct的默认权限是public cla
C++类和对象（一）
ll1175555的博客
07-13 1万+
目录面向过程和面向对象初步认识类的定义类的作用域类的实例化类的访问限定符及封装类的对象大小计算类成员函数this指针 面向过程和面向对象初步认识 C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。 C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。 比如一个外卖系统 面向过程：下单、接单、送餐三个过程 面向对象：客户、商家、骑手，关注的是三个类对象之间的关系 类的定义 class Name { //类体:由成员函数和成员变量组成
c++类和对象（类的概念）
m0_58103115的博客
03-24 5206
1.类和对象概念 类：用来对实体（对象）进行描述，对象有什么属性，以及对象具有什么功能是一种自定义类型 对象：现实生活中所存在的 ，对象是对类的具体体现 用类类型创建出来的变量称为对象 2.类的定义 class[类名] { //类体：成员变量属性，成员变量功能 } 方法一：将类的声明和定义全部放在类中定义 方法二：在头文件中放类的声明，在源文件中放类的定义 5.类的访问限定符及封装 6.类的对象大小计算 7.类成员对象的this指针 ...
C++类和对象
wh22141334的博客
07-18 3951
c++中的类和对象
C++类对象和类指针的区别
热门推荐
Arcobaleno
04-17 2万+
好奇这个，所以参考了一些帖子，写下心得。 一篇转载率较高的帖子：C++ 类对象和 指针的区别 大佬都不贴结果。。。。所以这里我给出代码和结果： #include<iostream> using namespace std; class Test{ public: int a; Test(){ a = 1; } }; int main...
C++类对象的创建方式
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
06-11 5915
C++类对象的创建方式
(C++)类与对象
weixin_53812805的博客
05-22 1万+
一、类与对象的思想 面向对象的特点：封装、继承、多态 面向对象编程的特点： （1）易维护：可读性高，即使改变了需求，由于继承的存在，只需要对局部模块进行修改，维护起来非常方便，维护的成本也比较低。 （2）质量高：可以重用以前项目中已经被测试过的类，使系统满足业务需求从而具有更高的质量 （3）效率高：在软件开发时，根据设计的需求要对现实世界的事物进行抽象，从而产生了类 （4）易扩展：由于继承、封装、多态的特性，可设计出高内聚、低耦合的系统结构，使系统更加灵活、更容易扩展，而且成本也比较低。 1、
C++的.和-＞的区别
qq_45701131的博客
09-07 3392
C++的.和->运算符的区别
C++类对象进行排序
taoxing
08-29 4976
写在前面 C++类对象按照某一个属性进行排序很早以前就学习过，但是时间久了开始有点遗忘了，现在就把最常用的一共方法进行以下总结。 一. 二.
C++初阶+类和对象（上）.pdf
01-17
本节课将介绍C++中的类和对象的概念，包括面向过程和面向对象的初步认识、类的引入、类的定义、类的访问限定符及封装、类的作用域、类的实例化、类对象模型、this指针等内容。 1. 面向过程和面向对象初步认识 ...
C++类和对象练习 实现日期类
07-29
为了更好的理解`C++`类和对象的知识,我们可以动手实现一下`C++`的一个简单的日期类,完成相应的函数,更好的帮助我们理解类和对象. 从日期类的构造函数,拷贝构造,获取当月天数,日期与天数的运算,日期类相关的比较...
C++类和对象.
10-09
类和对象.ppt 类和对象.ppt,文档
【C语言】Top K问题【建小堆】
2301_80840905的博客
08-04 476
在我们生活中，经常会遇到TopK问题。建小堆解决
C++ STL copy, move 用法
08-04 225
前向（从前向后的顺序）拷贝/移动操作，将一个容器元素拷贝/移动到另一容器中。
【C++】输入输出
2401_83948390的博客
08-02 528
在C++中，输入输出操作主要通过标准库中的iostream头文件提供的一系列对象和函数来完成。
OD C卷 - 中庸行者
最新发布
weixin_45228198的博客
08-04 187
DFS
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值