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

C++学习之对象特性

2024-07-03 46
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 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++学习特性
百锦再@新空间代码工作室
目录
相关文章
是乙太呀
|
9天前
|
算法 网络安全 区块链
2023/11/10学习记录-C/C++对称分组加密DES
本文介绍了对称分组加密的常见算法（如DES、3DES、AES和国密SM4）及其应用场景，包括文件和视频加密、比特币私钥加密、消息和配置项加密及SSL通信加密。文章还详细展示了如何使用异或实现一个简易的对称加密算法，并通过示例代码演示了DES算法在ECB和CBC模式下的加密和解密过程，以及如何封装DES实现CBC和ECB的PKCS7Padding分块填充。
是乙太呀
30 4
2023/11/10学习记录-C/C++对称分组加密DES
chian-ocean
|
1月前
|
安全 编译器 C++
【C++11】新特性
`C++11`是2011年发布的`C++`重要版本，引入了约140个新特性和600个缺陷修复。其中，列表初始化（List Initialization）提供了一种更统一、更灵活和更安全的初始化方式，支持内置类型和满足特定条件的自定义类型。此外，`C++11`还引入了`auto`关键字用于自动类型推导，简化了复杂类型的声明，提高了代码的可读性和可维护性。`decltype`则用于根据表达式推导类型，增强了编译时类型检查的能力，特别适用于模板和泛型编程。
chian-ocean
24 2
ephemerals__
|
1月前
|
存储 编译器 C++
【c++】类和对象（下）（取地址运算符重载、深究构造函数、类型转换、static修饰成员、友元、内部类、匿名对象）
本文介绍了C++中类和对象的高级特性，包括取地址运算符重载、构造函数的初始化列表、类型转换、static修饰成员、友元、内部类及匿名对象等内容。文章详细解释了每个概念的使用方法和注意事项，帮助读者深入了解C++面向对象编程的核心机制。
ephemerals__
103 5
ephemerals__
|
1月前
|
存储 编译器 C++
【c++】类和对象（中）（构造函数、析构函数、拷贝构造、赋值重载）
本文深入探讨了C++类的默认成员函数，包括构造函数、析构函数、拷贝构造函数和赋值重载。构造函数用于对象的初始化，析构函数用于对象销毁时的资源清理，拷贝构造函数用于对象的拷贝，赋值重载用于已存在对象的赋值。文章详细介绍了每个函数的特点、使用方法及注意事项，并提供了代码示例。这些默认成员函数确保了资源的正确管理和对象状态的维护。
ephemerals__
90 4
ephemerals__
|
1月前
|
存储 编译器 Linux
【c++】类和对象（上）（类的定义格式、访问限定符、类域、类的实例化、对象的内存大小、this指针）
本文介绍了C++中的类和对象，包括类的概念、定义格式、访问限定符、类域、对象的创建及内存大小、以及this指针。通过示例代码详细解释了类的定义、成员函数和成员变量的作用，以及如何使用访问限定符控制成员的访问权限。此外，还讨论了对象的内存分配规则和this指针的使用场景，帮助读者深入理解面向对象编程的核心概念。
ephemerals__
108 4
梦笔生花伟
|
2月前
|
编译器 C语言 C++
配置C++的学习环境
【10月更文挑战第18天】如果想要学习C++语言，那就需要配置必要的环境和相关的软件，才可以帮助自己更好的掌握语法知识。 一、本地环境设置 如果您想要设置 C++ 语言环境，您需要确保电脑上有以下两款可用的软件，文本编辑器和 C++ 编译器。 二、文本编辑器 通过编辑器创建的文件通常称为源文件，源文件包含程序源代码。 C++ 程序的源文件通常使用扩展名 .cpp、.cp 或 .c。 在开始编程之前，请确保您有一个文本编辑器，且有足够的经验来编写一个计算机程序，然后把它保存在一个文件中，编译并执行它。 Visual Studio Code：虽然它是一个通用的文本编辑器，但它有很多插
梦笔生花伟
67 6
白子寰
|
2月前
|
存储 编译器 对象存储
【C++打怪之路Lv5】-- 类和对象（下）
【C++打怪之路Lv5】-- 类和对象（下）
白子寰
32 4
白子寰
|
2月前
|
编译器 C语言 C++
【C++打怪之路Lv4】-- 类和对象（中）
【C++打怪之路Lv4】-- 类和对象（中）
白子寰
32 4
希望_睿智
|
2月前
|
C++
C++ 20新特性之结构化绑定
在C++ 20出现之前，当我们需要访问一个结构体或类的多个成员时，通常使用.或->操作符。对于复杂的数据结构，这种访问方式往往会显得冗长，也难以理解。C++ 20中引入的结构化绑定允许我们直接从一个聚合类型（比如：tuple、struct、class等）中提取出多个成员，并为它们分别命名。这一特性大大简化了对复杂数据结构的访问方式，使代码更加清晰、易读。
希望_睿智
44 0
白子寰
|
2月前
|
存储 编译器 C语言
【C++打怪之路Lv3】-- 类和对象（上）
【C++打怪之路Lv3】-- 类和对象（上）
白子寰
21 0