牛客网 SQL36查找后排序

SQL36查找后排序

select device_id,age from user_profile order by age asc
#select [字段1,字段2] from [表名] order by [字段1] [升序(asc)/降序(desc)],[字段2] [升序(asc)/降序(desc)]
#select:查询
#order by 排序

每日问题

如何实现对象的克隆?

在 C++ 中,实现对象的克隆通常涉及到复制对象的状态,以便创建一个新的对象,其内容与原始对象相同。克隆通常是通过深拷贝来实现的,特别是当对象包含动态分配的内存或资源时,使用浅拷贝可能导致资源共享和潜在的问题(如双重删除)。下面是实现对象克隆的一些常见方式。

1. 通过拷贝构造函数实现克隆

拷贝构造函数是用来创建一个对象,该对象是另一个对象的副本。默认情况下,拷贝构造函数执行浅拷贝,即复制对象的成员变量。但对于需要深拷贝的类(例如,包含动态内存分配的类),需要自己实现拷贝构造函数。

示例:

#include <iostream>
#include <cstring>  // for strcpyclass Person {
public:char* name;int age;// 构造函数Person(const char* n, int a) {name = new char[strlen(n) + 1];strcpy(name, n);age = a;}// 拷贝构造函数:实现深拷贝Person(const Person& other) {name = new char[strlen(other.name) + 1];strcpy(name, other.name);age = other.age;}// 析构函数~Person() {delete[] name;}// 打印函数void print() const {std::cout << "Name: " << name << ", Age: " << age << std::endl;}
};int main() {Person p1("John", 30);  // 创建一个对象Person p2 = p1;  // 使用拷贝构造函数克隆 p1p1.print();p2.print();return 0;
}

输出:

Name: John, Age: 30
Name: John, Age: 30

在这个例子中,Person 类有一个拷贝构造函数,它深拷贝了对象的 name 字符串和 age 整数。new 操作符确保了 name 字符串的深拷贝,避免了浅拷贝可能带来的资源共享问题。

2. 通过克隆接口实现克隆

如果你的类层次结构比较复杂,可能有一个基类,并且需要让派生类支持克隆操作,可以定义一个 clone() 方法。通常,clone() 方法返回一个指向新对象的指针,确保每个派生类都能正确实现其克隆。

为了实现这种方法,通常使用 虚函数 和 工厂方法。

示例:

#include <iostream>
#include <cstring>class Shape {
public:virtual ~Shape() = default;// 克隆接口virtual Shape* clone() const = 0;virtual void draw() const = 0;
};class Circle : public Shape {
public:Circle(int r) : radius(r) {}// 克隆方法:实现圆形的深拷贝Shape* clone() const override {return new Circle(*this);  // 使用拷贝构造函数克隆}void draw() const override {std::cout << "Drawing a circle with radius " << radius << std::endl;}private:int radius;
};class Rectangle : public Shape {
public:Rectangle(int w, int h) : width(w), height(h) {}// 克隆方法:实现矩形的深拷贝Shape* clone() const override {return new Rectangle(*this);  // 使用拷贝构造函数克隆}void draw() const override {std::cout << "Drawing a rectangle with width " << width << " and height " << height << std::endl;}private:int width, height;
};int main() {Shape* circle = new Circle(5);Shape* rectangle = new Rectangle(10, 20);// 克隆对象Shape* clonedCircle = circle->clone();Shape* clonedRectangle = rectangle->clone();// 调用 draw 方法circle->draw();rectangle->draw();clonedCircle->draw();clonedRectangle->draw();// 释放内存delete circle;delete rectangle;delete clonedCircle;delete clonedRectangle;return 0;
}

输出:

Drawing a circle with radius 5
Drawing a rectangle with width 10 and height 20
Drawing a circle with radius 5
Drawing a rectangle with width 10 and height 20

在这个例子中,我们创建了一个 Shape 基类,并在每个派生类(Circle 和 Rectangle)中实现了 clone() 方法。clone() 方法返回一个新创建的对象,确保每个派生类都能正确地进行深拷贝。

3. 使用 std::unique_ptr 或 std::shared_ptr 实现克隆

如果对象的管理使用智能指针,可以通过智能指针来管理对象的生命周期。在这种情况下,克隆通常会涉及到复制智能指针所管理的对象。

示例:

#include <iostream>
#include <memory>  // for unique_ptrclass MyClass {
public:MyClass(int x) : data(x) {}MyClass(const MyClass& other) : data(other.data) {}  // 拷贝构造函数void print() const {std::cout << "Data: " << data << std::endl;}private:int data;
};int main() {std::unique_ptr<MyClass> ptr1 = std::make_unique<MyClass>(10);// 克隆 ptr1std::unique_ptr<MyClass> ptr2 = std::make_unique<MyClass>(*ptr1);ptr1->print();ptr2->print();return 0;
}

输出:

Data: 10
Data: 10

在这个例子中,我们使用 std::unique_ptr 来管理 MyClass 的对象。在克隆时,我们通过 std::make_unique 和拷贝构造函数来创建新对象。

4. 通过工厂方法实现克隆

如果你希望将克隆操作与类的实例化分离,可以使用工厂方法来创建和克隆对象。这种方法特别适用于需要根据不同参数构造对象的情况。

示例:

#include <iostream>class Animal {
public:virtual ~Animal() = default;virtual Animal* clone() const = 0;virtual void speak() const = 0;
};class Dog : public Animal {
public:Dog* clone() const override {return new Dog(*this);  // 使用拷贝构造函数克隆}void speak() const override {std::cout << "Woof!" << std::endl;}
};class Cat : public Animal {
public:Cat* clone() const override {return new Cat(*this);  // 使用拷贝构造函数克隆}void speak() const override {std::cout << "Meow!" << std::endl;}
};int main() {Animal* dog = new Dog();Animal* cat = new Cat();// 克隆对象Animal* clonedDog = dog->clone();Animal* clonedCat = cat->clone();dog->speak();cat->speak();clonedDog->speak();clonedCat->speak();delete dog;delete cat;delete clonedDog;delete clonedCat;return 0;
}

输出:

Woof!
Meow!
Woof!
Meow!

总结

在 C++ 中实现对象克隆的主要方法有:

        1.通过拷贝构造函数实现克隆:适用于大多数简单的对象。需要自己编写拷贝构造函数,确保正确进行深拷贝。

        2.通过克隆接口(clone() 方法)实现克隆:适用于有继承关系的类,能够让基类定义一个虚拟的 clone() 方法,派生类实现具体的克隆逻辑。

        3.使用智能指针管理克隆:适用于使用智能指针(如 std::unique_ptr 或 std::shared_ptr)管理资源的对象,可以通过拷贝构造来克隆。

        4.通过工厂方法实现克隆:通过一个专门的工厂方法来创建和克隆对象,适用于需要动态生成对象的情况。

如何实现单例模式?

在 C++ 中,单例模式(Singleton Pattern)是一种常用的设计模式,用于确保一个类只有一个实例,并且提供一个全局访问点来获取该实例。单例模式通常用于管理全局资源(如数据库连接、日志对象等),保证在应用程序的生命周期中只创建一个实例。

单例模式的关键特性:

        1.私有构造函数:防止外部直接创建对象。

        2.静态成员:用于存储类的唯一实例。

        3.公有静态方法:提供访问该实例的方式。

单例模式的基本实现

#include <iostream>class Singleton {
private:// 私有构造函数,防止外部直接创建对象Singleton() {std::cout << "Singleton created!" << std::endl;}// 私有拷贝构造函数和赋值运算符,防止复制对象Singleton(const Singleton&) = delete;Singleton& operator=(const Singleton&) = delete;public:// 提供获取实例的静态方法static Singleton& getInstance() {static Singleton instance;  // 局部静态变量,保证实例只创建一次return instance;}void showMessage() const {std::cout << "Hello from Singleton!" << std::endl;}
};int main() {// 获取单例实例并调用方法Singleton& singleton1 = Singleton::getInstance();singleton1.showMessage();// 再次获取单例实例并调用方法Singleton& singleton2 = Singleton::getInstance();singleton2.showMessage();// 检查两个实例是否是同一个if (&singleton1 == &singleton2) {std::cout << "Both instances are the same." << std::endl;} else {std::cout << "Instances are different." << std::endl;}return 0;
}
解释:

1.私有构造函数:构造函数是私有的,这样外部代码无法直接创建 Singleton 对象。

2.静态 getInstance() 方法:getInstance() 方法是唯一可以获取 Singleton 实例的入口。它返回 Singleton 类的一个静态局部实例,这样确保实例只有一个,并且在第一次调用时创建。C++ 中的静态局部变量会在第一次访问时初始化,并且在程序结束时自动销毁。

3.禁止拷贝和赋值:通过删除拷贝构造函数和赋值运算符,防止对象被复制。

线程安全的实现(C++11及以上)

上面的实现是线程安全的,因为局部静态变量在 C++11 中是线程安全的。在 C++11 标准中,局部静态变量的初始化是线程安全的,即使多个线程同时访问 getInstance(),也不会创建多个实例。

单例模式的变种:懒汉式与饿汉式

懒汉式:实例在第一次使用时创建。需要考虑线程安全。

饿汉式:在程序启动时就创建实例,不管是否需要。简单且线程安全,但如果实例的创建成本较高,可能会浪费资源。

1. 懒汉式实现(线程安全)
#include <iostream>
#include <mutex>class Singleton {
private:Singleton() {std::cout << "Singleton created!" << std::endl;}Singleton(const Singleton&) = delete;Singleton& operator=(const Singleton&) = delete;static std::mutex mutex;  // 保护实例的互斥锁public:static Singleton* getInstance() {static Singleton* instance = nullptr;// 双重检查锁定,确保线程安全且避免不必要的加锁if (instance == nullptr) {std::lock_guard<std::mutex> lock(mutex);if (instance == nullptr) {instance = new Singleton();}}return instance;}void showMessage() const {std::cout << "Hello from Singleton!" << std::endl;}
};std::mutex Singleton::mutex;  // 初始化静态成员 mutexint main() {Singleton* singleton1 = Singleton::getInstance();singleton1->showMessage();Singleton* singleton2 = Singleton::getInstance();singleton2->showMessage();if (singleton1 == singleton2) {std::cout << "Both instances are the same." << std::endl;}return 0;
}
解释:

1.懒汉式实现:实例只有在第一次访问时才会被创建(即 "懒加载")。使用 std::mutex 来保护实例的创建,以确保在多线程环境中只有一个实例。

2.双重检查锁定:通过 if (instance == nullptr) 进行第一次检查,如果仍然是 nullptr,才加锁创建实例。这样避免了每次获取实例时都加锁,提高了性能。

2. 饿汉式实现
#include <iostream>class Singleton {
private:// 私有构造函数Singleton() {std::cout << "Singleton created!" << std::endl;}Singleton(const Singleton&) = delete;Singleton& operator=(const Singleton&) = delete;static Singleton instance;  // 在程序启动时就创建实例public:static Singleton& getInstance() {return instance;}void showMessage() const {std::cout << "Hello from Singleton!" << std::endl;}
};// 定义静态成员变量
Singleton Singleton::instance;int main() {Singleton& singleton1 = Singleton::getInstance();singleton1.showMessage();Singleton& singleton2 = Singleton::getInstance();singleton2.showMessage();if (&singleton1 == &singleton2) {std::cout << "Both instances are the same." << std::endl;}return 0;
}
解释:

1.饿汉式实现:实例在程序启动时就被创建,并且是线程安全的,因为静态成员 instance 会在程序加载时初始化。

2.没有延迟创建:实例在程序启动时就创建,无论是否需要,可能会浪费资源。

总结

1.懒汉式(Lazy Initialization):

        实例延迟创建,直到第一次访问时。

        需要考虑线程安全,可以使用 std::mutex 或 C++11 中的线程安全局部静态变量。

        优点:实例创建时机可控,节省资源。

        缺点:需要额外的线程同步机制来保证线程安全。

2.饿汉式(Eager Initialization):

        实例在程序启动时就创建。

        简单且线程安全,但可能浪费资源,尤其是当实例创建代价较高时。

在大多数情况下,懒汉式更为灵活,尤其是当实例创建过程可能比较耗时或者实例未必每次都会使用时。使用静态局部变量的懒汉式在 C++11 及以上版本中非常推荐,它既是线程安全的,又实现了延迟加载。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/diannao/64797.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

浅析InnoDB引擎架构(已完结)

大家好&#xff0c;我是此林。 今天来介绍下InnoDB底层架构。 1. 磁盘架构 我们所有的数据库文件都保存在 /var/lib/mysql目录下。 由于我这边是docker部署的mysql&#xff0c;用如下命令查看mysql数据挂载。 docker inspect mysql-master 如下图&#xff0c;目前只有一个数…

Ajax中的axios

既然提到Ajax&#xff0c;那就先来说一说什么是Ajax吧 关于Ajax Ajax的定义 Asynchronous JavaScript And XML&#xff1a;异步的JavaScript和XML。 反正就是一句话总结&#xff1a; 使用XML HttpRequest 对象与服务器进行通讯。 AJAX 是一种在无需重新加载整个网页的情况下&…

苹果手机怎么清理空间:拯救你的拥挤手机

在数字生活的海洋中&#xff0c;我们的苹果手机就像一艘小船&#xff0c;载满了照片、应用、视频和各种下载的“宝贝”。随着时间的推移&#xff0c;这艘小船开始变得拥挤&#xff0c;航行速度放缓&#xff0c;甚至有时候直接卡壳。苹果手机怎么清理空间&#xff1f;是时候学会…

三、使用langchain搭建RAG:金融问答机器人--检索增强生成

经过前面2节数据准备后&#xff0c;现在来构建检索 加载向量数据库 from langchain.vectorstores import Chroma from langchain_huggingface import HuggingFaceEmbeddings import os# 定义 Embeddings embeddings HuggingFaceEmbeddings(model_name"m3e-base")#…

C语言 函数嵌套

#include <stdio.h> void new_line() {printf("hehe\n"); } void three_line() {int i 0;for (i 0; i < 3; i){new_line;} } int main() {three_line();return 0; } 函数可以嵌套调用&#xff0c;但不能嵌套定义 链式访问 main有三个参数 //main函数的…

问题解决:发现Excel中的部分内容有问题。是否让我们尽量尝试恢复? 如果您信任此工作簿的源,请单击“是”。

在开发同步导出功能是遇到了如标题所示的问题&#xff0c;解决后遂记录下来供大家参考。 RestController public class XxxController {PostMapping("/export")public BaseResponse export(RequestBody PolicyErrorAnalysisExportReq exportReq, HttpServletRespons…

基于ST STM32MP257FAK3的MP2控制器之工业PLC 方案

简介 1.可编程逻辑控制器&#xff08;PLC&#xff09;是种专门为在工业环境下应用而设计的数字运算操作电子系统。它采用一种可编程的存储器&#xff0c;在其内部存储执行逻辑运算、顺序控制、定时、计数和算术运算等操作的指令&#xff0c;通过数字式或模拟式的输入输出来控制…

golang自定义MarshalJSON、UnmarshalJSON 原理和技巧

问题出现的原因&#xff1a;在前后端分离的项目中&#xff0c;经常出现的问题是时间戳格式的问题。 后端的日期格式兼容性强&#xff0c;比较完善。前端由于各种原因&#xff0c;日期格式不完善。 就会产生矛盾。 ms int64比较通用&#xff0c;但是unix时间没有可读性&#xff…

初始Python篇(7)—— 正则表达式

找往期文章包括但不限于本期文章中不懂的知识点&#xff1a; 个人主页&#xff1a;我要学编程(ಥ_ಥ)-CSDN博客 所属专栏&#xff1a; Python 目录 正则表达式的概念 正则表达式的组成 元字符 限定符 其他字符 正则表达式的使用 正则表达式的常见操作方法 match方法的…

使用 AI 辅助开发一个开源 IP 信息查询工具:一

本文将分享如何借助当下流行的 AI 工具,一步步完成一个开源项目的开发。 写在前面 在写代码时&#xff0c;总是会遇到一些有趣的机缘巧合。前几天&#xff0c;我在翻看自己之前的开源项目时&#xff0c;又看到了 DDNS 相关的讨论。虽然在 2021 年我写过两篇相对详细的教程&am…

Powershell学习笔记

声明&#xff01; 学习视频来自B站up主 **泷羽sec** 有兴趣的师傅可以关注一下&#xff0c;如涉及侵权马上删除文章&#xff0c;笔记只是方便各位师傅的学习和探讨&#xff0c;文章所提到的网站以及内容&#xff0c;只做学习交流&#xff0c;其他均与本人以及泷羽sec团队无关&a…

《Java源力物语》-2.异常训练场

~犬&#x1f4f0;余~ “我欲贱而贵&#xff0c;愚而智&#xff0c;贫而富&#xff0c;可乎&#xff1f; 曰&#xff1a;其唯学乎” \quad 在java.lang古域的一处偏僻角落&#xff0c;矗立着一座古老的训练场。青灰色的围墙上布满了密密麻麻的源力符文&#xff0c;这些符文闪烁着…

一起学Git【第二节:创建版本库】

创建库 这个库相当于一个目录&#xff0c;目录中的文件都被Git管理&#xff0c;会记录每个文件的修改删除和添加工作&#xff0c;便于之后随时跟踪历史记录还原到之前的某一版本。如何创建库呢&#xff1f;有两种方式&#xff0c;本地创建库和云端克隆一个库。 1.本地创建库 …

HarmonyOS NEXT 技术实践-基于基础视觉服务的多目标识别

在智能手机、平板和其他智能设备日益智能化的今天&#xff0c;视觉识别技术成为提升用户体验和智能交互的重要手段。HarmonyOS NEXT通过基础视觉服务&#xff08;HMS Core Vision&#xff09;提供了一套强大的视觉识别功能&#xff0c;其中多目标识别作为其关键技术之一&#x…

nginx-静态资源部署

目录 静态资源概述 静态资源配置指令 listen指令 server_name指令 精确匹配 ​编辑 ​编辑 使用通配符匹配 使用正则表达式匹配 匹配执行顺序 default_server属性 location指令 root指令 alias指令 root与alisa指令的区别 index指令 error_page指令 直接使用 …

时空信息平台架构搭建:基于netty封装TCP通讯模块(IdleStateHandler网络连接监测,处理假死)

文章目录 引言I 异步TCP连接操作II 心跳机制:空闲检测(读空闲和写空闲)基于Netty的IdleStateHandler类实现心跳机制(网络连接监测)常规的处理假死健壮性的处理假死方案获取心跳指令引言 基于netty实现TCP客户端:封装断线重连、连接保持 https://blog.csdn.net/z92911896…

Linux之RPM和YUM命令

一、RPM命令 1、介绍 RPM(RedHat Package Manager).,RedHat软件包管理工具&#xff0c;类似windows里面的setup,exe是Liux这系列操作系统里而的打包安装工具。 RPMI包的名称格式&#xff1a; Apache-1.3.23-11.i386.rpm “apache’” 软件名称“1.3.23-11” 软件的版本号&am…

aosp15 - Activity生命周期切换

本文探查的是&#xff0c;从App冷启动后到MainActivity生命周期切换的系统实现。 调试步骤 在com.android.server.wm.RootWindowContainer#attachApplication 方法下断点&#xff0c;为了attach目标进程在com.android.server.wm.ActivityTaskSupervisor#realStartActivityLock…

【漫话机器学习系列】017.大O算法(Big-O Notation)

大 O 表示法&#xff08;Big-O Notation&#xff09; 大 O 表示法是一种用于描述算法复杂性的数学符号&#xff0c;主要用于衡量算法的效率&#xff0c;特别是随着输入规模增大时算法的运行时间或占用空间的增长趋势。 基本概念 时间复杂度 描述算法所需的运行时间如何随输入数…

ensp 基于端口安全的财务部网络组建

ARP IP数据包通过以太网发送&#xff0c;但以太网设备并不能识别IP地址&#xff0c;它们是以MAC地址传输的。因此&#xff0c;必须把IP目的地址转换成MAC目的地址。在以太网中&#xff0c;一个主机要和另一个主机进行直接通信&#xff0c;必须要知道目标主机的MAC地址。 ARP&…