C++之make_unique、namespace、class类总结(二百四十二)

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

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

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

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

1.前言

本篇目的：理解C++之make_unique、namespace、class类用法。

2.make_unique、namespace和class类介绍

• 1. make_unique：make_unique 是 C++14 中引入的一个函数模板，用于创建一个独占所有权的智能指针（std::unique_ptr）。它可以动态分配内存并初始化对象，并且在构造函数抛出异常时自动释放内存，从而避免了内存泄漏的风险。make_unique 函数接受构造函数参数并返回包含该对象的 unique_ptr。使用 make_unique 可以简化动态内存分配的过程，并提高代码的安全性。
• 2. namespace：命名空间是一种将全局作用域分割为不同部分的机制，以避免命名冲突。命名空间可以包含变量、函数、类和其他命名空间。通过将相关的代码组织在命名空间中，可以更好地组织和管理代码。使用命名空间可以避免在较大的项目中发生名称冲突，并提高代码的可读性和可维护性。
• 3. class类：在面向对象编程中，类是一种用户定义的数据类型，用于封装数据和方法。类将数据和相关的操作（方法）组合在一起，形成了一个对象的抽象表示。类通常用于建模现实世界的实体或概念，并提供了封装、继承和多态等特性。

  类的定义包含了成员变量和成员函数。成员变量用于存储对象的状态和属性，而成员函数用于操作和访问这些成员变量。通过实例化类的对象，可以调用对象的成员函数来处理数据和执行操作。

  类还可以通过访问限定符（public、private、protected）来控制成员的访问权限。public 成员可以从类的外部访问，private 成员只能在类的内部访问，而 protected 成员可以在类的派生类中访问。

• 4.make_unique 用于安全地动态分配和初始化对象，命名空间提供了避免命名冲突的机制，类则用于建立对象的抽象模型，封装数据和相关操作。

3.实例

1. 在命名空间中使用 make_unique 创建一个类的实例：

namespace MyNamespace {
    class MyClass {
    public:
        MyClass() {
            std::cout << "MyClass constructor" << std::endl;
        }
    };
}

int main() {
    auto obj = std::make_unique<MyNamespace::MyClass>();
    // 输出: MyClass constructor
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2. 在命名空间中使用 make_unique 创建一个类的实例，并传递构造函数参数：

namespace MyNamespace {
    class MyClass {
    public:
        MyClass(int value) : mValue(value) {
            std::cout << "MyClass constructor, value: " << mValue << std::endl;
        }

    private:
        int mValue;
    };
}

int main() {
    auto obj = std::make_unique<MyNamespace::MyClass>(42);
    // 输出: MyClass constructor, value: 42
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3. 在命名空间中使用 make_unique 创建一个指向类对象数组的 unique_ptr：

namespace MyNamespace {
    class Point {
    public:
        Point(int x, int y) : mX(x), mY(y) {}

        void print() {
            std::cout << "Point: (" << mX << ", " << mY << ")" << std::endl;
        }

    private:
        int mX;
        int mY;
    };
}

int main() {
    const int size = 5;
    auto points = std::make_unique<MyNamespace::Point[]>(size);

    for (int i = 0; i < size; ++i) {
        points[i] = MyNamespace::Point(i, i);
        points[i].print();
    }

    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

4. 在命名空间中使用 make_unique 创建一个带有初始化列表的类对象：

namespace MyNamespace {
    class MyClass {
    public:
        MyClass(std::initializer_list<int> values) {
            std::cout << "MyClass constructor, values: ";
            for (const auto& value : values) {
                std::cout << value << " ";
            }
            std::cout << std::endl;
        }
    };
}

int main() {
    auto obj = std::make_unique<MyNamespace::MyClass>({1, 2, 3, 4});
    // 输出: MyClass constructor, values: 1 2 3 4
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

5. 创建一个带有命名空间和类的层级结构，在命名空间中使用 make_unique 创建类的实例：

namespace MyNamespace {
    namespace SubNamespace {
        class MyClass {
        public:
            MyClass() {
                std::cout << "MyClass constructor" << std::endl;
            }
        };
    }
}

int main() {
    auto obj = std::make_unique<MyNamespace::SubNamespace::MyClass>();
    // 输出: MyClass constructor
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

6. 在类的构造函数中使用 make_unique 创建类的成员对象：

class MyClass {
public:
    MyClass() : mPtr(std::make_unique<int>(42)) {}

private:
    std::unique_ptr<int> mPtr;
};

int main() {
    MyClass obj;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

7. 在类的静态成员函数中使用 make_unique 创建类对象：

class MyClass {
public:
    static void createObject() {
        auto obj = std::make_unique<MyClass>();
    }
};

int main() {
    MyClass::createObject();
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11

8.多层嵌套namespace命名空间 v1.0

#include 
#include 
#include 

namespace android {
  namespace impl {
    class HWComposer {
    public:
      HWComposer(const std::string& serviceName)
        : mServiceName(serviceName) {
      }

      void printServiceName() {
	printf("xxx-------------->%s(), line = %d, ServiceName = %s\n",__FUNCTION__,__LINE__,mServiceName.c_str());
      }

    private:
      std::string mServiceName;
    };
  } // namespace impl
} // namespace android

int main() {
  std::string serviceName = "SurfaceFlinger";
  std::unique_ptr<android::impl::HWComposer> hwComposer  = std::make_unique<android::impl::HWComposer>(serviceName);
  hwComposer->printServiceName();

  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

9.多层嵌套namespace命名空间 v2.0

#include 
#include 
#include 

namespace android {
  namespace impl {
    class HWComposer {
    public:
      HWComposer(const std::string& serviceName)
        : mServiceName(serviceName) {
      }

      void printServiceName() {
	printf("xxx-------------->%s(), line = %d, ServiceName = %s\n",__FUNCTION__,__LINE__,mServiceName.c_str());	
      }

    private:
      std::string mServiceName;
    };
  } // namespace impl
} // namespace android


std::unique_ptr<android::impl::HWComposer> getinstance(std::string serviceName){
  return std::make_unique<android::impl::HWComposer>(serviceName);
}

int main() {
  std::string serviceName = "SurfaceFlinger";
  std::unique_ptr<android::impl::HWComposer> hwComposer  = getinstance(serviceName); 
  hwComposer->printServiceName();
  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