C++类的学习（基础篇）

最新推荐文章于 2024-07-25 18:18:36 发布
最新推荐文章于 2024-07-25 18:18:36 发布
阅读量190 收藏
点赞数
分类专栏： C++入门学习 文章标签： c++ 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54706831/article/details/128826090
版权
类是C++中的自定义类型，结合数据成员和成员函数。类包含private和public访问控制，用于封装数据。构造函数用于初始化对象，析构函数在对象销毁时执行清理工作。成员函数包括内联函数、const成员函数，如get_average()和show()。this指针允许在成员函数中引用当前对象。
摘要由CSDN通过智能技术生成

类

  • 类是一种自定义类型，类似于结构体。
  • 类将数据表示和操纵数据的方法组合成一个整洁的包。

类的组成

  • 类声明：以数据成员的方式描述数据部分，以成员函数（被称为方法）的方式描述公有接口。
  • 类方法定义：描述如何实现类成员函数。

类声明

class Student   // 关键字class标识类定义
{
    // 默认是私有的
        int m_math;     // 私有成员
    private:    // 私有成员
        std::string m_name;     // 成员变量
        int m_English;
        int m_Chinese;
        int m_sum;
        void set_sum()          // 内联方法
        {
            m_sum = m_math + m_English + m_Chinese;
        }
    public:     // 公有成员
        Student();      // 默认构造函数
        Student(std::string name)  // 构造函数
        {
            m_name = name;
        }
        Student(std::string name, int math, int English, int Chinese);   // 构造函数
        void set_scores(int math, int English, int Chinese);    // 公有成员函数
        double get_average() const;     // const成员函数
        void show() const;      // const成员函数
        ~Student();     // 析构函数
};

说明

  1. 关键字class表示类定义。
  2. 访问控制: 关键字private和public描述了对类成员的访问控制
    • public: 使用类对象的程序可以直接访问公有部分数据
    • private: 只能通过公有成员函数或者友元函数来访问私有部分数据
  3. 可以不必在类声明中使用关键字private，因为类对象的默认访问控制是private。

实现类成员函数

  • 定义成员函数时，使用作用域解析运算符::来标识函数所属的类。
  • 类方法可以访问类的private成员
Student::Student()
{
    m_name = "";
    m_math = 0;
    m_Chinese = 0;
    m_English = 0;
    m_sum = 0;
}

Student::Student(std::string name, int math, int English, int Chinese)
{
    m_name = name;
    set_scores(math,English,Chinese);
}

void Student::set_scores(int math, int English, int Chinese)
{
    m_math = math;
    m_English = English;
    m_Chinese = Chinese;
    set_sum();      // 调用私有方法
}

double Student::get_average() const
{
    return (double)m_sum / 3;
}
void Student::show() const
{
    std::cout << "name: " << m_name << std::endl;
    std::cout << "math: " << m_math << std::endl;
    std::cout << "English: " << m_English << std::endl;
    std::cout << "Chinese: " << m_Chinese << std::endl;
    std::cout << "Sum: " << m_sum << std::endl;
}
Student::~Student()
{
    std::cout << "This is destructor!" << std::endl;
}

内联方法

定义位于类声明中的函数都将自动成为内联函数，所以set_sum()是一个内联函数。

如果想在类声明外定义成员函数为内联函数，只要在函数定义时使用inline限定符即可。

class Student
{
    private:
        ...
        void set_sum();
        ...
};
inline void Student::set_sum()
{
    m_sum = m_math + m_English + m_Chinese;
}

类的构造函数和析构函数

构造函数专门用于构造新对象、将值赋给他们的数据成员（做初始化工作）。

默认构造函数

类设计时如果没有提供任何构造函数，C++会自动提供一个默认构造函数。它是默认构造函数的隐式版本，不做任何工作。

类似于int a 创建了a但没有赋值。

Student::Student()
{
    
}

注意

只有当没有定义任何构造函数时，编译器才会提供默认构造函数。如果提供了构造函数，但是没有提供默认构造函数，则下面声明会报错

Student stu1;   // 没有默认构造函数

可以自己提供一个默认构造函数，给成员变量赋初值

Student::Student()
{
    m_name = "";
    m_math = 0;
    m_Chinese = 0;
    m_English = 0;
    m_sum = 0;
}

析构函数

用构造函数创建对象，对象过期时，程序会自动调用析构函数，用来完成清理工作。（做清理工作）

析构函数的名称是在类名前加上~

Student::~Student()
{
    std::cout << "This is destructor!" << std::endl;
}

如果程序员没有提供析构函数，C++会隐式地声明一个默认析构函数。

Student::~Student()
{
    
}

如果使用了new创建成员变量，必须在析构函数中使用delete释放掉该成员变量。

Student~Student()
{
    delete var;
}

析构函数何时被调用

  1. 如果创建的是静态存储类对象，则其析构函数将在程序结束时自动被调用。
  2. 如果创建的是自动存储类对象，则其析构函数将在执行完代码块时自动被调用。
  3. 如果对象是通过new创建的，当使用delete来释放内存时，其析构函数将自动被调用。

const成员函数

为了确保调用成员函数时，调用对象不被修改，可以将成员函数声明为const成员函数，在声明时，在函数后面加上const关键字。

// 声明
void show() const;

// 定义
void Student::show() const
{
    ...
}

使用类

使用对象的成员函数，和使用结构体成员一样，通过成员运算符.或->。

int main()
{
    Student stu1;   // 默认构造函数
    stu1.show();    // 调用公有成员函数
    Student stu2("zhangsan");
    stu2.set_scores(90,98,88);
    std::cout << stu2.get_average() << std::endl;
    stu2.show();
    Student stu3("lisi", 89,85,94);
    stu3.show();

    Student *stu4 = new Student;
    stu4->show();

    Student *stu5 = new Student("wangwu", 90,90,90);
    stu5->show();
    delete stu4;
    delete stu5;
}

this指针

每一个类对象中都有一个this指针指向本对象。比如在给成员变量赋值时使用this指针

Student::Student(std::string name, int math, int English, int Chinese)
{
    this->m_name = name;
    this->set_scores(math,English,Chinese);
}

使用this指针实例

比较两个学生的平均数，并返回高分数的学生

class Student
{
    ...
    public:
        const Student &topval(const Student &) const;
    ...
}

const Student & Student::topval(const Student &stu) const
{
    if(this->get_average() > stu.get_average())
    {
        return *this;		// 返回本对象
    }
    else
    {
        return stu;
    }
}

int main()
{
    Student stu2("zhangsan");
    stu2.set_scores(90,98,88);
    std::cout << stu2.get_average() << std::endl;
    stu2.show();
    Student stu3("lisi", 89,85,94);
    stu3.show();
    Student stu6 = stu2.topval(stu3);   // 比较stu2和stu3的成绩
    stu6.show();
}

整体代码

#include <iostream>
#include <string>

using namespace std;

class Student   // 关键字class标识类定义
{
    // 默认是私有的
        int m_math;     // 私有成员
    private:    // 私有成员
        std::string m_name;     // 成员变量
        int m_English;
        int m_Chinese;
        int m_sum;
        void set_sum()          // 内联方法
        {
            m_sum = m_math + m_English + m_Chinese;
        }
    public:     // 公有成员
        Student();      // 默认构造函数
        Student(std::string name)  // 构造函数
        {
            m_name = name;
            m_English = 0;
            m_Chinese = 0;
            m_math = 0;
            set_sum();
        }
        Student(std::string name, int math, int English, int Chinese);   // 构造函数
        void set_scores(int math, int English, int Chinese);    // 公有成员函数
        double get_average() const;
        void show() const;
        const Student &topval(const Student &) const;
        ~Student();   // 析构函数
};

int main()
{
    Student stu1;   // 默认构造函数
    stu1.show();    // 调用公有成员函数
    Student stu2("zhangsan");
    stu2.set_scores(90,98,88);
    std::cout << stu2.get_average() << std::endl;
    stu2.show();
    Student stu3("lisi", 89,85,94);
    stu3.show();

    Student stu6 = stu2.topval(stu3);
    cout << "higher scores" << endl;
    stu6.show();
    cout << endl;
    Student *stu4 = new Student;
    stu4->show();

    Student *stu5 = new Student("wangwu", 90,90,90);
    stu5->show();
    delete stu4;
    delete stu5;
}
const Student & Student::topval(const Student &stu) const
{
    if(this->get_average() > stu.get_average())
    {
        return *this;
    }
    else
    {
        return stu;
    }
}
Student::Student()
{
    m_name = "";
    m_math = 0;
    m_Chinese = 0;
    m_English = 0;
    m_sum = 0;
}

Student::Student(std::string name, int math, int English, int Chinese)
{
    this->m_name = name;
    this->set_scores(math,English,Chinese);
}

void Student::set_scores(int math, int English, int Chinese)
{
    m_math = math;
    m_English = English;
    m_Chinese = Chinese;
    set_sum();      // 调用私有方法
}

double Student::get_average() const
{
    return (double)m_sum / 3;
}
void Student::show() const
{
    std::cout << "name: " << m_name << std::endl;
    std::cout << "math: " << m_math << std::endl;
    std::cout << "English: " << m_English << std::endl;
    std::cout << "Chinese: " << m_Chinese << std::endl;
    std::cout << "Sum: " << m_sum << std::endl;
}
Student::~Student()
{
    std::cout << "This is destructor!" << std::endl;
}

作用域为类的常量

在类中定义常量，并使用这个常量定义一个数组

错误的写法

class Person
{
    private:
        const int size = 30; 
        char m_name[size];		// 错误
};

这样会报错，因为声明类只是描述了对象的形式，并没有创建对象。因此，在创建对象前，将没有用于存储值的空间。

可行的方法

  1. 方法一，在类中声明一个枚举

在类声明中声明的枚举的作用域为整个类，因此可以用枚举为整型常量提供作用域为整个类的符号名称。

class Person
{
    private:
        enum {size = 30;};
        char m_name[size];
};

用这种方式声明枚举并不会创建类数据成员。也就是说，所有对象中都不包括枚举。size只是一个符号枚举，在作用域为整个类的代码中遇到它时，编译器将用30来替换它。类似于宏定义。

  1. 方法二，使用关键字static
class Person
{
    private:
        static const int size = 30;
        cahr m_name[size];
};

这样声明的常量将与其他静态变量存储在一起，而不是存储在对象中。

实例

#include <iostream>
#include <cstring>
using namespace std;

class Person
{
	private:
		static const int size = 30;
		// enum { size = 30 };
		char m_name[size];
	public:
		Person();
		Person(const char *name);
		friend ostream &operator<<(ostream &os, const Person& p);
};
int main()
{
	Person p1("zhangsan");
	cout << p1 << endl;
	return 0;
}

Person::Person()
{
	m_name[0] = '\0';
}
Person::Person(const char *name)
{
	strncpy(m_name, name, size - 1);
}

ostream &operator<<(ostream &os, const Person& p)
{
	os << p.m_name;
	return os;
}
C/C++学习路线总结与分享
dvlinker的技术专栏
10-07 9万+
C/C++学习路线总结与分享
C++ 类学习
qq_39751437的博客
04-30 307
C++ 创建类对象有两种方法： 参考资料 使用new创建类对象：C++用new创建对象时返回的是一个对象指针，内存分配是分配到堆上，使用完需要delete(只有delete对象才会调用其析构函数)删除对象来释放空间，如myRec->getArea(); 使用普通方法创建类对象 内存分配是分配到栈上 由C++缺省创建和撤销，自动调用构造函数(分配空间)和析构函数(释放空间)，如myRec....
c++类的学习
weixin_30247307的博客
08-14 116
#include<iostream> #include<stdlib.h> #include<string> #include<time.h> using namespace std; class Array { public: void set(); void show(); void find...
c++学习(类的学习)
myth's blog
12-03 1034
1.       结构体Struct 名称{类型名 变量; //定义成员数据成员函数;};与类相似,可以使用public,private,protected.默认public. 2.       共用体Union 名称{类型名 变量1;类型名 变量2;类型名 变量3;}; 任何时刻,共用体只有一个成员起作用,且共用体所有成员共用一个存储
C++ 类和对象基础篇
08-25
"C++ 类和对象基础篇" 本节课程主要讲解了 C++ 中的类和对象基础知识。类是创建对象的模板，一个类可以创建多个对象，每个对象都是类类型的一个变量；创建对象的过程也叫类的实例化。每个对象都是类的一个具体实例...
C++学习基础篇.zip
最新发布
08-05
C++学习基础篇.zip
C++编程实例100篇
08-28
《C++编程实例100篇》是一本深入浅出的C++编程教程，它以实践为主导，通过丰富的实例帮助学习者掌握C++语言的基础和核心概念。这本书的每个实例都精心设计，旨在帮助初学者和有经验的开发者巩固和提升C++编程技能。 ...
C++学习指南（语法篇）代码+pdf(pdf可直接打印)
03-03
这是 C/C++学习指南(语法篇) 对应的视频教材! 面向零基础的初学者。同时，书中还讲解了初级程序员所必须掌握的知识和技术，如“单步调试”，“编码规范”， ANSI函数库，文件操作，标准模板库STL的使用。 学习方法：...
C++类基础学习（1）
qianbao55的博客
03-18 611
C++学习笔记1：类的定义、类成员使用、静态成员的特点以及使用，struct与类区别等等
c++ 类 (要学习类这一篇就够了 )
2301_80772499的博客
07-25 1644
用 9159 个字详细讲解c++的类。值得一看。
C++ 语言学习入门--类
hz_Oliver_ZHANG的博客
02-17 1412
C++ 类入门相关
c++类学习
Youjingqi的博客
02-08 511
本次简单总结一下类中的运算符重载，构造函数，析构函数。
C++类学习
技术爬虫(tech-reptile)
06-08 1272
类——一个用户定义的类型1、类的定义一、struct实现日期的概念    struct Data{        int d,m,y;    };    void init_data(Data& d,int,int,int);    void add_year(Data& d,int n);    void add_month(Data& d,int m);    void add_data(Da
C++类 学习（一）
ACERROR
04-27 140
C++中的私有属性，只能在类的内部（或其友元）中访问。 构造函数是一种特殊的函数(方法)，在根据类创建对象时被调用。与函数一样，构造函数也可以 重载。 ::被称作为作用域解析运算符。例如，Human::dateOfBirth指的是在Human类中声明的变量dateOfBirth，而::dateOfBirth表示全局作用域中的变量dateOfBirth。 初始化成员的方式：构造函数、初始化列表。 析构函数： 每当对象不再在作用域内或通过delete被删除进而被销毁时，都将调用析构函数。这使得析构函数成为重置变
C++学习 类
离乱生花的博客
09-29 262
新手学C++，看能不能帮上小忙
【C++】C++类的学习（一）——初识类
热门推荐
不用先生的博客
03-24 1万+
  【fishing-pan：https://blog.csdn.net/u013921430转载请注明出处】 前言        C++在C语言的基础上做了一些改进，使得C++具有了面向对象编程（Object Oriented Programming，OOP）的特性。其中最重要的改进就是提供了类的概念。可以说学习了C++却不会使用类的话，那么就没有学习到C++的精髓。        在接...
c++中类的学习（一）
sk91324的博客
05-13 364
1.首先总结一下class和struct的区别： struct在c++中可以包含成员函数，可以继承，也可以实现多态，他们最本质的区别是class默认的访问权限是private，而class是public “class”这个关键字还用于定义模板参数，就像“typename”，但关键字“struct”不用于定义模板参数 struct更适合看成是一个数据结构的实现体，class更适
c++学习——类
Mtchy的专栏
10-21 328
公共、私有和保护 public：都可以访问 private：给类成员函数和友元 protected：具有private特性，并可被派生类成员函数访问 默认的控制是private 成员函数定义： 内部定义默认为inline函数 外部定义： void cPerson::disp( ) disp是cPers
C++面向对象基础：类与封装
"这篇文档是关于C++基础知识中的类，主要介绍了面向对象的思想，包括抽象、封装和数据隐蔽等核心概念。" C++是一种强大的、支持面向对象编程（Object-Oriented Programming, OOP）的编程语言。面向对象的思想起源于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值