【Cpp筑基】三、对象和类

于 2024-08-07 15:00:23 发布
阅读量531 收藏 9
点赞数 6
分类专栏： # C\Cpp 文章标签： cpp c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44940689/article/details/140962363
版权

【Cpp筑基】三、对象和类

文章目录

1. 类

Cpp相比于C语言新增了类的概念，因此Cpp是一种面向对象的编程语言而C语言只是一种面向过程的编程语言。类是一种将抽象转换为用于自定义的Cpp工具，它将数据表示和操纵数据的方法组合成一个整洁的包。

一般来说，类规范由两部分组成：

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

1.1 类的一个简单示例

简单来说，类声明提供了类的蓝图，而方法定义则提供了类实现的细节。举一个例子：

my_class.h文件中存放了类的声明

// my_class.h
#ifndef MY_CLASS_H
#define MY_CLASS_H

#include <iostream>
#include <string>

// 类声明
class Person {
public:
    // 构造函数
    Person(const std::string &name, int age);
    // 公有接口：成员函数
    void display() const;
    void setAge(int age);
    int getAge() const;
private:
    // 数据成员
    std::string name;
    int age;
};

#endif

my_class.cpp中存放了类的方法定义

// my_class.cpp
#include "my_class.h"
// 构造函数实现
Person::Person(const std::string &name, int age) : name(name), age(age) {}

// display 方法实现
void Person::display() const {
    std::cout << "Name: " << name << ", Age: " << age << std::endl;
}

// setAge 方法实现
void Person::setAge(int age) {
    if (age > 0) {
        this->age = age;
    } else {
        std::cout << "Invalid age!" << std::endl;
    }
}

// getAge 方法实现
int Person::getAge() const {
    return age;
}

1.2 类的访问权限

Cpp中类的访问权限有三种：

  • public，公有，类的成员可以从类的外部直接访问。任何对象或函数都可以访问public成员
  • protected，保护，类的成员不能从类的外部直接访问，但可以被派生类（继承该类的类）访问。
  • private，私有，访问权限表示成员不能从类的外部直接访问，也不能被派生类访问。只有类的成员函数和友元函数可以访问private成员。

需要注意的是，在Cpp中访问权限是相对类的外部而言的，在类的内部来说，所有的变量和成员函数都是可以互相访问的。公有public方法也可以访问私有private成员变量和方法，Cpp类的成员函数，无论其访问级别如何，都可以访问该类中的所有成员，包括私有成员，这是因为成员函数被认为是类的一部分，拥有该类的所有细节的权限。

在Cpp中可以使用关键字struct或者class来声明一个类，它们的使用方式基本相同，唯一不同之处在于struct声明的成员默认访问权限为public，而class声明的成员默认访问权限是private。

数据隐藏作为面向对象编程（Object Orient Program，OOP）的主要目的，因此数据项通常放在私有部分，组成类接口的成员函数放在公有部分；否则就无法从程序中调用这些函数。通常，我们使用私有成员函数来处理不属于公有接口的实现细节。

1.3 内联方法

如果在一个类中，其成员函数的定义放在类的声明中，那么该成员函数将被自动转化为内联函数，以减小开销。内联函数是一种建议编译器在每次调用该函数时，将其代码插入到调用点处，而不是进行常规的函数调用。这可以减少函数调用的开销，提高程序执行效率，尤其是对于短小的函数。举个例子：

#include <iostream>

class MyClass {
public:
    // 在类声明中定义的函数,自动转化成内联函数
    void printMessage() const {
        std::cout << "Hello, Inline Function!" << std::endl;
    }
};

int main() {
    MyClass obj;
    obj.printMessage(); // 调用内联函数
    return 0;
}

当然我们也可以手动在类声明之外定义内联成员函数。举个例子：

#include <iostream>

class MyClass {
public:
    void printMessage() const;  // 声明时不需要 inline
};

// 定义时使用 inline
inline void MyClass::printMessage() const {
    std::cout << "Hello, Inline Function!" << std::endl;
}

int main() {
    MyClass obj;
    obj.printMessage();
    return 0;
}

1.4 构造函数和析构函数

在C++中，构造函数和析构函数是特殊的成员函数，用于在对象的生命周期内执行初始化和清理操作。构造函数在对象创建时自动调用，而析构函数在对象销毁时自动调用。

构造函数是用于初始化对象的特殊成员函数。构造函数的名称与类名相同，并且没有返回类型。构造函数可以被重载，即一个类可以有多个构造函数，只要它们的参数（特征标）不同。

构造函数的特点是：

  • 名称与类名相同
  • 没有返回类型
  • 在对象创建时自动调用
  • 可以被重载
  • 可以使用初始化列表
  • 不能成为虚函数

举个例子：

#include <iostream>

class MyClass {
public:
    int x;
private:
    // 默认构造函数
    MyClass() {
        x = 0;
        std::cout << "Default Constructor called" << std::endl;
    }
    // 参数化构造函数
    MyClass(int value) {
        x = value;
        std::cout << "Parameterized Constructor called" << std::endl;
    }
    // 拷贝构造函数
    MyClass(const MyClass& obj) {
        x = obj.x;
        std::cout << "Copy Constructor called" << std::endl;
    }
};

int main() {
    MyClass obj1;              // 调用默认构造函数
    MyClass obj2(10);          // 调用参数化构造函数
    MyClass obj3 = obj2;       // 调用拷贝构造函数
    return 0;
}

这里重载了构造函数，提供了三种构造函数，当类被示例化的时候会从构造函数中选择符合特征标的构造函数进行调用。

成员名称与参数名，不熟悉构造函数的程序员可能会将类成员名称用作构造函数的参数名，例如：

class MyClass {
public:
    int x; // 成员变量

    MyClass(int x) { // 构造函数参数名与成员变量名相同
        x = x; // 这是错误的
    }
};

为了解决这种问题，我们可以在数据成员名前面增加_或者一些其他的标识，例如：

class MyClass {
public:
    int _x; // 成员变量

    MyClass(int x) { // 这是可行的，没有名称冲突
        _x = x; 
    }
};

或者使用this指针来显示地指明

class MyClass {
public:
    int x; // 成员变量

    MyClass(int x) { // 这是可行的，使用this指针
        this->x = x; 
    }
};

或者使用构造函数初始化列表，例如：

class MyClass {
public:
    int x; // 成员变量

    MyClass(int x) : x(x) { // 使用初始化列表
        // 这样更直观，并且避免了赋值操作
    }
};

如果没有提供构造函数，那么编译器会为我们添加一个默认构造函数，只不过这个构造函数什么也不执行；一个默认拷贝构造函数，并且重载赋值运算符=，允许我们直接拷贝已有的对象实例。

默认的构造函数，举个例子：

#include <iostream>

class MyClass {
public:
    int x;
    double y;
};

int main() {
    MyClass obj; // 使用编译器生成的默认构造函数
    std::cout << "x: " << obj.x << ", y: " << obj.y << std::endl; // 未定义行为
    return 0;
}

在这个类MyClass中，我们并没有定义构造函数，编译器自动帮我们生成了一个构造函数，这个构造函数什么都不做，所以x和y是没有赋值的，在最后一行的打印语句中将会报错。

默认拷贝构造函数，举个例子：

#include <iostream>

class MyClass {
public:
    int x;
    double y;
};

int main() {
    MyClass obj1;
    obj1.x = 10;
    obj1.y = 20.5;
    
    MyClass obj2 = obj1; // 使用编译器生成的默认拷贝构造函数
    std::cout << "obj2.x: " << obj2.x << ", obj2.y: " << obj2.y << std::endl;
    return 0;
}

在这个类MyClass中，我们并没有定义构造函数，编译器自动帮我们生成了一个拷贝构造函数，编译器生成的默认拷贝构造函数会逐个成员地进行浅拷贝。

重载运算符operator=，举个例子：

#include <iostream>

class MyClass {
public:
    int x;
    double y;
};

int main() {
    MyClass obj1;
    obj1.x = 10;
    obj1.y = 20.5;
    
    MyClass obj2;
    obj2 = obj1; // 使用编译器生成的默认赋值运算符
    std::cout << "obj2.x: " << obj2.x << ", obj2.y: " << obj2.y << std::endl;
    return 0;
}

编译器生成的默认赋值运算符（operator=）也会逐个成员地进行浅拷贝。

在Cpp中，析构函数是一个特殊的成员函数，用于在对象生命周期结束时执行清理工作，析构函数通常用于释放资源（如动态内存、文件句柄、网络连接等），确保对象在销毁时不会造成资源泄露。

析构函数的特点是：

  • 名称与类名相同，但前面加上波浪号~
  • 没有返回类型
  • 没有参数
  • 在对象生命周期结束时自动调用
  • 不能被重载，一个类只能有一个析构函数
  • 不能成为虚函数

例如：

#include <iostream>

class MyClass {
public:
    int* ptr;

    MyClass(int size) {
        ptr = new int[size];
        std::cout << "Constructor called" << std::endl;
    }

    ~MyClass() {
        delete[] ptr;
        std::cout << "Destructor called" << std::endl;
    }
};

int main() {
    MyClass obj(10); // 创建对象并分配内存
    // 离开作用域时自动调用析构函数，释放内存
    return 0;
}

如果你没有定义析构函数，那么编译器将会自动生成一个析构函数，该析构函数不执行任何操作，例如：

#include <iostream>

class Simple {
public:
    int x;

    Simple() : x(0) {
        std::cout << "Simple Constructor" << std::endl;
    }

    // 编译器会生成一个默认析构函数
    // ~Simple() { }
};

int main() {
    Simple obj; // 创建对象时调用构造函数
    return 0;   // 离开作用域时调用编译器生成的默认析构函数
}

1.5 C++11列表初始化

在C++11中，列表初始化语法也可以用于类中，只要提供与某个构造函数的参数列表匹配的内容，就可使用大括号{}进行列表初始化。

列表初始化类的对象，举个例子：

#include <iostream>

class MyClass {
public:
    int x;
    double y;
    // 默认构造函数
    MyClass(){}
    // 构造函数
    MyClass(int a, double b) : x(a), y(b) {
        std::cout << "MyClass constructed with x: " << x << ", y: " << y << std::endl;
    }
};

int main() {
	MyClass jock {};			//使用默认构造函数进行初始化
	MyClass alex {10, 2.5};		//使用构造函数进行初始化
	MyClass john {2, 5.1};		//使用构造函数进行初始化
    return 0;
}

列表初始化类的对象的数组，举个例子：

#include <iostream>

class MyClass {
public:
    int x;
    double y;
    // 默认构造函数
    MyClass(){}
    // 构造函数
    MyClass(int a, double b) : x(a), y(b) {
        std::cout << "MyClass constructed with x: " << x << ", y: " << y << std::endl;
    }
};

int main() {
    // 使用列表初始化来初始化类对象数组
    MyClass arr[3] = { 
    	{1, 2.5}, 
    	{3, 4.5}, 
    	{5, 6.5}, 
    };
	// 也可这样来初始化数组
	MyClass arry[3] = {
		MyClass(2, 2.5),
		MyClass(3, 1.5),
		MyClass(4, 6.5),
	};
    return 0;
}

1.6 const成员函数

在C++中，const成员函数是指那些不会修改类的成员变量的成员函数。通过在函数声明的末尾加上 const关键字，可以保证该函数不会修改对象的状态。这对于确保某些函数的调用不会意外地改变对象的状态非常有用，并且在设计接口和维护代码的稳定性方面起着重要作用。

const成员函数的基本使用，举个例子：

class MyClass {
public:
    int getValue() const; // 声明为const成员函数
private:
    int value;
};

int MyClass::getValue() const {
    return value; // 可以读取成员变量
    // value = 10; // 错误：不能修改成员变量
}

const对象和成员函数，const对象不能调用非const成员函数，而非const对象可以调用所有的成员函数，举个例子：

class MyClass {
public:
    int getValue() const;
    void setValue(int v);
private:
    int value;
};

int MyClass::getValue() const {
    return value;
}

void MyClass::setValue(int v) {
    value = v;
}

int main() {
    MyClass obj;
    obj.setValue(10);
    std::cout << obj.getValue() << std::endl; // 可以调用非const对象的所有成员函数

    const MyClass constObj;
    // constObj.setValue(10); // 错误：不能调用非const成员函数
    std::cout << constObj.getValue() << std::endl; // 只能调用const成员函数

    return 0;
}

1.7 this指针

在C++中，this指针是一个隐含在每个非静态成员函数中的特殊指针。它指向调用成员函数的对象，并且允许成员函数访问调用对象的成员变量和其他成员函数。this指针的主要作用是区分成员变量和局部变量，并在成员函数内部引用对象本身。

this指针的特点

  • 指向调用对象：this指针指向调用成员函数的对象本身。
  • 只在非静态成员函数中可用：静态成员函数没有this指针，因为静态成员函数是类级别的，而不是对象级别的。
  • 类型：this指针的类型是指向类类型的常量指针，例如对于类MyClass，this指针的类型是MyClass* const。
  • 常量性：this指针是一个常量指针，不能更改它指向的对象，但可以用来修改对象的成员。

使用this指针区分成员变量和局部变量，举个例子：

#include <iostream>

class MyClass {
private:
    int value;
public:
    MyClass(int value) {
        // 使用this指针区分成员变量和构造函数参数
        this->value = value;
    }
    void setValue(int value) {
        // 使用this指针区分成员变量和函数参数
        this->value = value;
    }
    void printValue() const {
        std::cout << "Value: " << this->value << std::endl;
    }
};

int main() {
    MyClass obj(10);
    obj.printValue();
    obj.setValue(20);
    obj.printValue();
    return 0;
}

使用this指针实现链式调用（返回*this），举个例子：

#include <iostream>

class MyClass {
private:
    int value;
public:
    MyClass(int value) : value(value) {}
    MyClass& setValue(int value) {
        this->value = value;
        return *this; // 返回对象本身的引用
    }
    MyClass& incrementValue() {
        ++this->value;
        return *this; // 返回对象本身的引用
    }
    void printValue() const {
        std::cout << "Value: " << this->value << std::endl;
    }
};
int main() {
    MyClass obj(10);
    obj.setValue(20).incrementValue().printValue(); // 链式调用
    return 0;
}

在这个例子中，我们实现了对象方法的链式调用，但链式调用更多地用在运算符重载当中，举个例子：

#include <iostream>

class MyClass {
private:
    int value;

public:
    MyClass(int value) : value(value) {}
    MyClass& operator+=(int other) {
        this->value += other;
        return *this;			// 返回*this
    }
    void printValue() const {
        std::cout << "Value: " << this->value << std::endl;
    }
};
int main() {
    MyClass obj(10);
    obj += 5;
    obj.printValue(); // 输出：Value: 15
    return 0;
}

Reference

《C++ Primer Plus》

木心
关注
  • 6
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
c++类和对象
includeevey的博客
10-06 7499
全文将讲解《类和对象》，文章比较长，请慢慢观看！
C++类和对象介绍（筑基上篇）
weixin_69509728的博客
09-18 294
C++基础介绍，类和对象，包括类的定义方式，类的访问限定符，C++封装概念及实现 ，类的作用域，类的实例化，类对象模型，this指针等细节
【Cpp筑基】二、声明 vs 定义、头文件、存储持续性作用域和链接性、名称空间
Shen Mu Xin's Blog
08-06 649
什么是声明？什么是定义？在C++中，声明（Declaration）和定义（Definition）是两个重要的概念，它们在程序的组织和编译过程中起着不同的作用。声明是告诉编译器某个变量、函数、类或者其他标识符的名称及其类型，但不包含具体的实现或者初始化，声明的主要目的是让编译器知道这些标识符的存在及类型。声明（Declaration）：告诉编译器某个变量的名字和类型，但不分配存储空间（除非它也是一个定义）。定义（Definition）：不仅告诉编译器变量的名字和类型，还分配存储空间。变量声明。
【Cpp筑基】一、内联函数、引用变量、函数重载、函数模板
Shen Mu Xin's Blog
08-06 734
左值（lvalue，locatable value）是指能够定位的值，它表示存储在内存中的某个位置的对象。因此，左值是可以取地址的，可以出现在赋值操作的左侧。右值（rvalue，readable value）是指不具有持久存储位置的临时值，它通常是表达式求值的结果。，如果两个函数的参数数目和类型相同，同时参数的排列顺序也相同，则它们的特征标相同，而变量名是不重要的。C++提供了一种内联函数，在 C++ 中，内联函数（inline function）是一种特殊的函数，其定义使用。例如，创建一个引用变量。
类和对象第二弹
2401_83052144的博客
04-05 802
4.如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的体大小就是所有最大对齐数(含嵌套结构体的对齐数)的整数倍。而对象在销毁时会自动调用析构函数，注释掉的是实际上运行的代码，编译器用了一个this指针来接受我们传过去的对象的地址，从而通过this来进行对象的调用。并且不指定，编译器不知道是谁的函数，只知道是一个全局函数，但是访问不了类中的成员变量，加了就知道是类的成员函数。其次，我们在计算类的大小时是不需要计算成员函数的大小的，他们不存在于对象的内存当中，存在与一个独立的空间。
【筑基篇】相比与C的升级C++经典—“类和对象”
DEXTERFUTIAN的博客
10-05 162
初步理解面向对象与面向过程，类的演化而来以及类的简单了解，this指针、实例化、作用域
Java筑基 - JNI到底是个啥
Java笔记虾
05-15 218
在前面介绍Unsafe的文章中，简单的提到了java中的本地方法（Native Method），它可以通过JNI（Java Native Interface）调用其他语言中的函数来实现一些...
菜鸟筑基——C++四种字符串类型的爱恨情仇
qq_34796146的博客
05-04 410
C++字符串详解 一、C语言风格的字符串 字符串是指使用‘\0’终止的字符串数组。 char a[6]={'H','e','l','l','o','\0'}; char* b = "Hello"; 以上的字符串在内存中的表示为 函数 作用 strcpy(s1,s2) 将s2字符串的内容复制给s1 strcat(s1,s2) 将s2字符串的内容拼接到s1后面，返回s1 ...
一文带你入门C++类和对象【十万字详解，一篇足够了】
做技术人 · 产优质博客 · 找好工作
04-29 3787
从类的封装思想谈到类的六大天选之子，最后探到类的边边角角。步步调试图解，带你入门C++类和对象
C++ 类和对象基础篇
08-25
"C++ 类和对象基础篇" 本节课程主要讲解了 C++ 中的类和对象基础知识。类是创建对象的模板，一个类可以创建多个对象，每个对象都是类类型的一个变量；创建对象的过程也叫类的实例化。每个对象都是类的一个具体实例...
类和对象.cpp
03-15
类和对象.cpp
3类和对象.cpp
11-28
3类和对象.cpp
类和对象1.cpp
06-14
类和对象1.cpp
C++ - 函数重载
jiaowenjie的专栏
08-06 187
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
C++ STL专题 list的讲解
最新发布
Mike的博客
08-07 482
1.list是可以在常数范围内任意位置进行插入和删除的序列式容器，并且可以前后双向迭代。2. list的底层是双链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。3. list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代。4. 与其他的序列式容器相比(vector，deque), list通常在任意位置进行插入，移除元素的执行效率更好。5. 与其他序列式容器相比，
C++ STL copy_backward, move_backward 用法
08-04 238
此处需要解释一下：从后向前并不是逆序，它的意思是: 源容器和目标容器都从尾部开始，然后向前迭代，执行拷贝/移动操作。反向（从后向前的顺序）拷贝/移动操作，将一个容器元素拷贝/移动到另一容器中。
伐木工 (100%用例)D卷 (Java&&Python&&C++&&Node.js&&C语言)
荆赫同艺的博客
08-07 23
一根 4米长的树木，伐木工不需要切割为 2*2，省去切割成本，直接整根树木交易，为 4*1，收益最大为 4。方式二: 3,2,2,3，但方式二，伐木工多切割一次，增加了切割成本却卖了一样的价格，因此并不是最优收益。一根 2 米长的树木，伐木工不切割，为2*1，收益最大为 2。一根5 米长的树木，伐木工切割为 2*3,收益最大为 6。输出最优收益时的各个树木长度，以空格分隔，按升序排列。一根 10 米长的树木，伐木工可以切割。方式一:3,4,4，也可以切割为。
【C++】输入输出
2401_83948390的博客
08-02 583
在C++中，输入输出操作主要通过标准库中的iostream头文件提供的一系列对象和函数来完成。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

木心

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值