C++之operator()和构造函数区别与总结(二百三十)

简介： CSDN博客专家，专注Android/Linux系统，分享多mic语音方案、音视频、编解码等技术，与大家一起成长！

优质专栏：Audio工程师进阶系列【原创干货持续更新中……】🚀

人生格言： 人生从来没有捷径，只有行动才是治疗恐惧和懒惰的唯一良药.

更多原创,欢迎关注：Android系统攻城狮

1.前言

本篇目的：理解C++之operator()和构造函数区别与总结。

2.operator()和构造函数区别

在C++中，operator()和构造函数是两个不同的概念和用法。

1. operator()：

   • operator()是一个函数调用运算符（Function Call Operator），它允许我们将一个对象像函数一样进行调用。
   • 通过在类中定义名为operator()的函数，可以使对象具有函数调用的行为，从而可以像调用函数一样使用对象。
   • 运算符()通过重载，可以根据参数和返回类型的不同，实现不同的行为。
   • 通常情况下，operator()被用于函数对象（Function Object）或仿函数（Functor），它们是一种特殊的对象，可以像函数一样进行调用。

2. 构造函数：

   • 构造函数是一种特殊的成员函数，在创建类对象时被自动调用，用于初始化对象的成员变量和执行其他必要的操作。
   • 构造函数的名称与类名相同，没有返回类型，包括默认构造函数、拷贝构造函数和其他重载的构造函数。
   • 默认构造函数用于在创建对象时不提供任何参数的情况下初始化对象。
   • 拷贝构造函数用于通过已有的对象创建一个新对象，复制已有对象的数据。

两者的区别和原理如下：

• operator()是一个运算符，它定义了对象的函数调用行为，使对象可以像函数一样被调用。
• 构造函数是一个特殊的成员函数，用于在创建对象时进行初始化操作。
• operator()通常用于函数对象或仿函数，而构造函数仅在对象被创建时调用。
• operator()可以接受参数并返回值，其行为是根据重载的不同而确定的。构造函数没有返回类型，仅用于对象的初始化。
• operator()的语法是在类中重载operator()运算符，而构造函数的语法是在类中定义一个与类同名的函数。
• operator()和构造函数都遵循函数调用的原理，但用途和使用方法有所不同。

3.operator()应用实例

v1.0

#include 

// 例子1：计算平方的函数对象
class Squarer {
public:
  int operator()(int x) const {
    return x * x;
  }
};

int main() {
  Squarer squarer;

  int result = squarer(5); // 调用squarer对象，相当于squarer.operator()(5)
  std::cout << "Squared value: " << result << std::endl;

  return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

v2.0

#include 
#include 

// 例子2：将字符串倒序输出的函数对象
class ReversePrinter {
public:
  void operator()(const std::string& str) const {
    for (int i = str.size() - 1; i >= 0; --i) {
      std::cout << str[i];
    }
    std::cout << std::endl;
  }
};

int main() {
  ReversePrinter reversePrinter;

  reversePrinter("Hello, World!"); // 调用reversePrinter对象，相当于reversePrinter.operator()("Hello, World!")

  return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

v3.0

#include 

// 例子3：计算平均值的函数对象
class AverageCalculator {
private:
  double sum;
  int count;

public:
  AverageCalculator() : sum(0), count(0) {}

  void operator()(double x) {
    sum += x;
    count++;
  }

  double getAverage() const {
    return sum / count;
  }
};

int main() {
  AverageCalculator averageCalculator;

  averageCalculator(4.5); // 调用averageCalculator对象，相当于averageCalculator.operator()(4.5)
  averageCalculator(7.3);
  averageCalculator(2.8);

  double average = averageCalculator.getAverage();
  std::cout << "Average: " << average << std::endl;

  return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

3.构造函数应用实例

v1.0 默认构造函数

#include 


class MyClass {
public:
  MyClass() {
    std::cout << "Default Constructor" << std::endl;
  }
};

int main() {
  MyClass obj; // 使用默认构造函数创建对象

  return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

v2.0 带参数的构造函数

#include 
class Point {
private:
  int x, y;

public:
  Point(int xPos, int yPos) : x(xPos), y(yPos) {
    std::cout << "Parameterized Constructor" << std::endl;
  }
};

int main() {
  Point obj(3, 4); // 使用带参数的构造函数创建对象

  return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

v3.0 拷贝构造函数

#include 

class MyString {
private:
  char* str;

public:
  MyString(const char* s) {
    // 在堆上分配内存保存字符串
    int length = strlen(s) + 1;
    str = new char[length];
    strncpy(str, s, length);
    std::cout << "Constructor" << std::endl;
  }

  MyString(const MyString& other) {
    // 深拷贝构造函数
    int length = strlen(other.str) + 1;
    str = new char[length];
    strncpy(str, other.str, length);
    std::cout << "Copy Constructor" << std::endl;
  }

  ~MyString() {
    // 销毁堆上分配的内存
    delete[] str;
    std::cout << "Destructor" << std::endl;
  }
};

int main() {
  MyString obj1("Hello"); // 使用带参数的构造函数创建对象
  MyString obj2(obj1);   // 使用拷贝构造函数创建对象

  return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36