备案控制台
开发者社区 安全 文章 正文

C++学习之对象特性

2024-07-03 8
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： C++学习之对象特性

C++对象特性有哪些

C++ 是一种多范式编程语言，它提供了许多特性来支持面向对象编程。下面是 C++ 中常见的对象特性：

  1. 封装（Encapsulation）：将数据和操作数据的方法打包在一起，对外部隐藏对象的内部实现细节，只暴露必要的接口给外部使用。
  2. 继承（Inheritance）：允许一个类（子类）继承另一个类（父类）的属性和行为，通过这种方式可以实现代码的重用和扩展。
  3. 多态（Polymorphism）：允许以统一的方式处理不同类型和不同类的对象，通过函数重载、运算符重载和虚函数实现多态性。
  4. 抽象（Abstraction）：隐藏对象复杂性的某些部分，只显示对象的关键特征，使得对象更易于理解和使用。
  5. 类与对象：类是对象的模板，定义了描述对象行为和状态的成员变量和成员函数；对象是类的实例化，具体存在并可以被使用。
  6. 构造函数与析构函数：构造函数用于初始化对象的状态，在对象创建时自动调用；析构函数用于清理对象分配的资源，在对象销毁时自动调用。
  7. 成员访问控制：通过访问修饰符（public、private、protected）控制成员变量和成员函数的访问权限，保证数据的安全性。
  8. 友元类和友元函数：友元类或友元函数可以访问类的私有成员，这在某些情况下提供了更灵活的访问权限。
  9. 静态成员：静态成员变量和静态成员函数属于类本身，而不是属于类的实例，可以通过类名直接访问，用于表示与类相关的共享属性和方法。

这些是 C++ 中常见的对象特性，它们使得 C++ 成为一种强大的面向对象编程语言，可以更好地组织和管理复杂的程序结构。

C++对象：构造函数和析构函数

构造函数和析构函数是 C++ 中的特殊成员函数，用于在对象生命周期的不同阶段执行初始化和清理操作。下面是构造函数和析构函数的各种情况以及相应的代码示例：

  1. 默认构造函数（Default Constructor）：当对象被创建时，如果没有显式提供构造函数，则会自动调用默认构造函数。默认构造函数不带任何参数。
class MyClass {
public:
    // 默认构造函数
    MyClass() {
        // 构造函数的代码逻辑
    }
};
int main() {
    // 调用默认构造函数创建对象
    MyClass obj;
    return 0;
}
  1. 有参构造函数（Parameterized Constructor）：当对象被创建时，可以使用提供参数的构造函数进行初始化。
class MyClass {
public:
    // 有参构造函数
    MyClass(int value) {
        // 构造函数的代码逻辑
    }
};
int main() {
    // 调用有参构造函数创建对象并传递参数
    MyClass obj(10);
    return 0;
}
  1. 拷贝构造函数（Copy Constructor）：当一个对象通过另一个对象进行初始化时，拷贝构造函数会被调用。
class MyClass {
public:
    // 拷贝构造函数
    MyClass(const MyClass& other) {
        // 构造函数的代码逻辑
    }
};
int main() {
    MyClass obj1;
    // 使用拷贝构造函数将 obj1 初始化为 obj2
    MyClass obj2(obj1);
    return 0;
}
  1. 移动构造函数（Move Constructor）：当一个对象通过右值引用进行初始化时，移动构造函数会被调用。移动构造函数通常用于提高性能和资源管理。
class MyClass {
public:
    // 移动构造函数
    MyClass(MyClass&& other) {
        // 构造函数的代码逻辑
    }
};
int main() {
    MyClass obj1;
    // 使用移动构造函数将 obj1 移动到 obj2
    MyClass obj2(std::move(obj1));
    return 0;
}
  1. 析构函数（Destructor）：在对象销毁时，析构函数会被自动调用，用于执行对象的清理操作。
class MyClass {
public:
    // 析构函数
    ~MyClass() {
        // 析构函数的代码逻辑
    }
};
int main() {
    // 创建对象
    MyClass obj;
    // 对象销毁时，析构函数被调用
    return 0;
}

这些是构造函数和析构函数的各种情况和相应的代码举例。根据具体的需求和实际情况，您可以选择适合的构造函数和析构函数来进行对象的初始化和清理操作。

C++对象：函数的分类和调用

在 C++ 中，函数可以根据其定义位置和用途进行分类。下面是常见的函数分类以及相应的调用情况和代码示例：

  1. 成员函数（Member Functions）：定义在类内部的函数称为成员函数，它们可以访问类的成员变量，并提供了对象操作和行为的封装。
class MyClass {
public:
    // 成员函数
    void memberFunction() {
        // 函数的代码逻辑
    }
};
int main() {
    MyClass obj;
    // 对象调用成员函数
    obj.memberFunction();
    return 0;
}
  1. 静态成员函数（Static Member Functions）：静态成员函数属于类本身，而不属于类的实例，可以通过类名直接调用而无需创建对象。
class MyClass {
public:
    // 静态成员函数
    static void staticFunction() {
        // 函数的代码逻辑
    }
};
int main() {
    // 直接调用静态成员函数
    MyClass::staticFunction();
    return 0;
}
  1. 友元函数（Friend Functions）：友元函数是定义在类外部但具有对类私有成员访问权限的函数。
class MyClass {
private:
    int privateData;
public:
    friend void friendFunction(MyClass& obj);
};
// 友元函数可以访问私有成员
void friendFunction(MyClass& obj) {
    obj.privateData = 10;
}
int main() {
    MyClass obj;
    // 调用友元函数
    friendFunction(obj);
    return 0;
}
  1. 构造函数（Constructors）：构造函数用于对象的初始化，在对象创建时自动调用。
class MyClass {
public:
    // 构造函数
    MyClass() {
        // 构造函数的代码逻辑
    }
};
int main() {
    // 创建对象时自动调用构造函数
    MyClass obj;
    return 0;
}
  1. 析构函数（Destructor）：析构函数在对象销毁时自动调用，用于执行对象的清理操作。
class MyClass {
public:
    // 析构函数
    ~MyClass() {
        // 析构函数的代码逻辑
    }
};
int main() {
    MyClass obj;
    // 对象销毁时自动调用析构函数
    return 0;
}
  1. 运算符重载函数（Operator Overloading）：通过定义特定名称的函数来重载运算符，扩展了原生的操作符的功能。
class MyClass {
public:
    int data;
    // 运算符重载函数
    MyClass operator+(const MyClass& other) {
        MyClass result;
        result.data = this->data + other.data;
        return result;
    }
};
int main() {
    MyClass obj1;
    obj1.data = 5;
    MyClass obj2;
    obj2.data = 10;
    // 调用运算符重载函数
    MyClass sum = obj1 + obj2;
    return 0;
}

C++对象：构造函数调用规则

在C++中，构造函数的调用规则可以根据不同情况进一步详细说明。以下是构造函数调用规则的各种情况和相应的代码示例：

  1. 默认构造函数的调用：如果没有显式提供构造函数，系统会自动生成默认构造函数并在对象创建时自动调用。
class MyClass {
public:
    // 默认构造函数
    MyClass() {
        // 构造函数的代码逻辑
    }
};
int main() {
    // 调用默认构造函数创建对象
    MyClass obj;
    return 0;
}
  1. 有参构造函数的调用：提供参数的构造函数将在对象创建时调用，并根据传入的参数进行初始化。
class MyClass {
public:
    // 有参构造函数
    MyClass(int value) {
        // 构造函数的代码逻辑
    }
};
int main() {
    // 调用有参构造函数创建对象并传递参数
    MyClass obj(10);
    return 0;
}
  1. 拷贝构造函数的调用：当一个对象通过另一个对象进行初始化时，拷贝构造函数会被调用。
class MyClass {
public:
    // 拷贝构造函数
    MyClass(const MyClass& other) {
        // 构造函数的代码逻辑
    }
};
int main() {
    MyClass obj1;
    // 使用拷贝构造函数将 obj1 初始化为 obj2
    MyClass obj2(obj1);
    return 0;
}
  1. 移动构造函数的调用：当一个对象通过右值引用进行初始化时，移动构造函数会被调用。
class MyClass {
public:
    // 移动构造函数
    MyClass(MyClass&& other) {
        // 构造函数的代码逻辑
    }
};
int main() {
    MyClass obj1;
    // 使用移动构造函数将 obj1 移动到 obj2
    MyClass obj2(std::move(obj1));
    return 0;
}
  1. 显式调用构造函数：可以通过直接调用构造函数来创建对象，这种情况下会显式调用构造函数。
class MyClass {
public:
    // 有参构造函数
    MyClass(int value) {
        // 构造函数的代码逻辑
    }
};
int main() {
    // 显式调用构造函数创建对象
    MyClass obj = MyClass(20);
    return 0;
}

C++对象：深拷贝和浅拷贝

在C++中，深拷贝和浅拷贝是用来描述在对象复制时对内存中数据的不同处理方式。下面解释深拷贝和浅拷贝的概念，并提供各种情况和代码示例：

  1. 浅拷贝（Shallow Copy）：浅拷贝只是简单地复制对象的值，如果对象包含指针变量，则仅复制指针地址，而不复制指针指向的实际内容。这可能导致多个对象共享相同的内存空间，一次修改可能会影响到其他对象。

示例代码：

#include <iostream>
#include <cstring>
class ShallowCopy {
private:
    char *data;
public:
    // 构造函数
    ShallowCopy(const char* value) {
        data = new char[strlen(value) + 1];
        strcpy(data, value);
    }
    // 拷贝构造函数（浅拷贝）
    ShallowCopy(const ShallowCopy& other) {
        data = other.data;
    }
    // 打印数据
    void printData() {
        std::cout << "Data: " << data << std::endl;
    }
};
int main() {
    ShallowCopy obj1("Hello");
    // 浅拷贝创建新对象 obj2
    ShallowCopy obj2 = obj1;
    obj1.printData();  // 输出 "Data: Hello"
    obj2.printData();  // 输出 "Data: Hello"
    // 修改 obj1 的数据
    obj1.printData();  // 输出 "Data: Bye"
    obj2.printData();  // 输出 "Data: Bye"
    return 0;
}
  1. 深拷贝（Deep Copy）：深拷贝会复制对象的所有数据，包括指针指向的内存块，这样每个对象都有自己独立的内存空间，互不影响。

示例代码：

#include <iostream>
#include <cstring>
class DeepCopy {
private:
    char *data;
public:
    // 构造函数
    DeepCopy(const char* value) {
        data = new char[strlen(value) + 1];
        strcpy(data, value);
    }
    // 深拷贝构造函数
    DeepCopy(const DeepCopy& other) {
        data = new char[strlen(other.data) + 1];
        strcpy(data, other.data);
    }
    // 打印数据
    void printData() {
        std::cout << "Data: " << data << std::endl;
    }
    // 析构函数
    ~DeepCopy() {
        delete[] data;
    }
};
int main() {
    DeepCopy obj1("Hello");
    // 深拷贝创建新对象 obj2
    DeepCopy obj2 = obj1;
    obj1.printData();  // 输出 "Data: Hello"
    obj2.printData();  // 输出 "Data: Hello"
    // 修改 obj1 的数据
    obj1.printData();  // 输出 "Data: Bye"
    obj2.printData();  // 输出 "Data: Hello"
    return 0;
}

以上代码，可以看出浅拷贝和深拷贝之间的区别。

C++对象：初始化和初始化列表的各种情况

在C++中，对象的初始化可以通过构造函数中的初始化列表来实现，也可以在构造函数内部通过赋值语句进行初始化。下面将介绍对象的初始化和初始化列表的各种情况，并提供相应的代码示例：

  1. 使用初始化列表进行初始化：初始化列表在构造函数参数后使用冒号进行指定，可以在对象创建时直接对成员变量进行初始化，提高效率。
#include <iostream>
class InitListExample {
private:
    int a;
    int b;
public:
    // 构造函数使用初始化列表进行初始化
    InitListExample(int x, int y) : a(x), b(y) {
        // 可以在此处添加其他初始化逻辑
    }
    void printData() {
        std::cout << "a: " << a << ", b: " << b << std::endl;
    }
};
int main() {
    InitListExample obj(10, 20);
    obj.printData(); // 输出 "a: 10, b: 20"
    return 0;
}
  1. 在构造函数内部进行赋值初始化：如果没有使用初始化列表，也可以在构造函数内部使用赋值语句对成员变量进行初始化。
#include <iostream>
class AssignmentInitExample {
private:
    int a;
    int b;
public:
    // 构造函数内部进行赋值初始化
    AssignmentInitExample(int x, int y) {
        a = x;
        b = y;
    }
    void printData() {
        std::cout << "a: " << a << ", b: " << b << std::endl;
    }
};
int main() {
    AssignmentInitExample obj(30, 40);
    obj.printData(); // 输出 "a: 30, b: 40"
    return 0;
}
  1. 初始化列表与默认参数的结合：初始化列表还可以与默认参数结合使用，在构造函数中指定默认值并且通过初始化列表进行初始化。
#include <iostream>
class DefaultParamInitExample {
private:
    int a;
    int b;
public:
    // 使用初始化列表与默认参数结合进行初始化
    DefaultParamInitExample(int x = 0, int y = 0) : a(x), b(y) {
        // 可以在此处添加其他初始化逻辑
    }
    void printData() {
        std::cout << "a: " << a << ", b: " << b << std::endl;
    }
};
int main() {
    DefaultParamInitExample obj1;
    obj1.printData(); // 输出 "a: 0, b: 0"
    DefaultParamInitExample obj2(50, 60);
    obj2.printData(); // 输出 "a: 50, b: 60"
    return 0;
}

以上代码示例，可以看到不同情况下如何使用初始化列表或在构造函数内部进行初始化，以及初始化列表与默认参数的结合使用。

C++对象：类对象作为类成员

在C++中，类对象可以作为类的成员变量，这样可以实现更复杂的数据结构和功能组合。下面将介绍类对象作为类成员的各种情况，并提供相应的代码示例：

  1. 类对象作为类的非静态成员：类对象可以作为类的非静态成员，在构造函数中进行初始化。
#include <iostream>
class InnerClass {
public:
    void printHello() {
        std::cout << "Hello from InnerClass!" << std::endl;
    }
};
class OuterClass {
private:
    InnerClass inner;
public:
    OuterClass() {
        // 可以在构造函数中对 inner 进行初始化
    }
    void callInner() {
        inner.printHello();
    }
};
int main() {
    OuterClass obj;
    obj.callInner(); // 输出 "Hello from InnerClass!"
    return 0;
}
  1. 类对象作为类的静态成员：类对象还可以作为类的静态成员，所有类的对象会共享静态成员。
#include <iostream>
class StaticClass {
public:
    static int count; // 静态成员变量
    void printCount() {
        std::cout << "Count: " << count << std::endl;
    }
};
int StaticClass::count = 0; // 静态成员变量初始化
class OuterClass {
public:
    static StaticClass obj; // 静态成员对象
};
StaticClass OuterClass::obj; // 静态成员对象定义
int main() {
    OuterClass::obj.count = 10;
    OuterClass obj1;
    OuterClass obj2;
    obj1.obj.printCount(); // 输出 "Count: 10"
    obj2.obj.printCount(); // 输出 "Count: 10"
    obj1.obj.count = 20;
    obj1.obj.printCount(); // 输出 "Count: 20"
    obj2.obj.printCount(); // 输出 "Count: 20"
    return 0;
}

通过以上代码示例，可以看到类对象作为类成员的两种情况。

关注我，不迷路，共学习，同进步

关注我，不迷路，共学习，同进步

文章标签：
C++
数据安全/隐私保护
关键词：
C++对象
C++学习
C++学习对象
C++学习特性
C++对象特性
百锦再@新空间代码工作室
目录
相关文章
百锦再@新空间代码工作室
|
2天前
|
存储 C++ 索引
C++ 学习之Map容器
C++ 学习之Map容器
百锦再@新空间代码工作室
8 1
百锦再@新空间代码工作室
|
2天前
|
存储 C++ 容器
C++ 学习之Set容器
C++ 学习之Set容器
百锦再@新空间代码工作室
6 1
ForcibleBugMaker
|
1天前
|
编译器 C++
【C++】类和对象⑤（static成员 | 友元 | 内部类 | 匿名对象）
📚 C++ 知识点概览：探索类的`static`成员、友元及应用🔍。
ForcibleBugMaker
3 0
笨笨小乌龟
|
1天前
|
C++
C++基础知识（四：类的学习）
类指的就是对同一类对象，把所有的属性都封装起来，你也可以把类看成一个高级版的结构体。
笨笨小乌龟
9 0
百锦再@新空间代码工作室
|
2天前
|
算法 C++ 容器
C++ 学习之函数对象
C++ 学习之函数对象
百锦再@新空间代码工作室
7 0
百锦再@新空间代码工作室
|
2天前
|
C++ 容器
C++学习之list容器
C++学习之list容器
百锦再@新空间代码工作室
6 0
百锦再@新空间代码工作室
|
2天前
|
存储 调度 C++
C++ 学习之Stack和Queue
C++ 学习之Stack和Queue
百锦再@新空间代码工作室
6 0
ForcibleBugMaker
|
1天前
|
编译器 C++
【C++】string类的使用④（字符串操作String operations ）
这篇博客探讨了C++ STL中`std::string`的几个关键操作，如`c_str()`和`data()`，它们分别返回指向字符串的const char*指针，前者保证以&#39;\0&#39;结尾，后者不保证。`get_allocator()`返回内存分配器，通常不直接使用。`copy()`函数用于将字符串部分复制到字符数组，不添加&#39;\0&#39;。`find()`和`rfind()`用于向前和向后搜索子串或字符。`npos`是string类中的一个常量，表示找不到匹配项时的返回值。博客通过实例展示了这些函数的用法。
ForcibleBugMaker
11 1
ForcibleBugMaker
|
1天前
|
存储 C++
【C++】string类的使用③（非成员函数重载Non-member function overloads）
这篇文章探讨了C++中`std::string`的`replace`和`swap`函数以及非成员函数重载。`replace`提供了多种方式替换字符串中的部分内容，包括使用字符串、子串、字符、字符数组和填充字符。`swap`函数用于交换两个`string`对象的内容，成员函数版本效率更高。非成员函数重载包括`operator+`实现字符串连接，关系运算符（如`==`, `&lt;`等）用于比较字符串，以及`swap`非成员函数。此外，还介绍了`getline`函数，用于按指定分隔符从输入流中读取字符串。文章强调了非成员函数在特定情况下的作用，并给出了多个示例代码。
ForcibleBugMaker
6 1
ForcibleBugMaker
|
1天前
|
C++
【C++】string类的使用④（常量成员Member constants）
C++ `std::string` 的 `find_first_of`, `find_last_of`, `find_first_not_of`, `find_last_not_of` 函数分别用于从不同方向查找目标字符或子串。它们都返回匹配位置，未找到则返回 `npos`。`substr` 用于提取子字符串，`compare` 则提供更灵活的字符串比较。`npos` 是一个表示最大值的常量，用于标记未找到匹配的情况。示例代码展示了这些函数的实际应用，如替换元音、分割路径、查找非字母字符等。
ForcibleBugMaker
6 0