C++刷题时应该返回对象还是返回对象的指针？

最新推荐文章于 2023-07-09 08:11:59 发布
最新推荐文章于 2023-07-09 08:11:59 发布
阅读量592 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： c++ 算法 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/j___t/article/details/120398142
版权

本文仅针对C++写算法题时，遇到要返回对象的情况时，应该返回对象还是返回对象的指针做出探讨。

众所周知，C++的变量和java、python不同，C++的变量并不是天然的指针，所以对象类型的变量之间的赋值远比java、python耗时，例如下列代码：

//cpp
vector<int> a(10000);
vector<int> b = a;    // 拷贝构造，a和b两个vector有各自的独立空间，需要消耗时间和空间

//python
a = [0 for _ in range(10000)]
b = a    # 地址赋值，把对象a的地址赋给了b，a和b指向同一个list，几乎不需要消耗时间和空间

在使用C++写算法题时，偶尔会遇到函数中返回对象的场景，那么是直接返回对象比较好，还是应该返回一个对象的指针呢？相信不少人担心直接返回对象会发生临时的构造，从而导致消耗大量时间，造成最后TLE。于是我进行了一些实验：

要解决的题目是Leetcode 2003. 每棵子树内缺失的最小基因值，使用暴力合并的解法（无法AC，仅为了实验），在leetcode和codeforces上构造测试用例进行测试（看看在极端环境下的表现）。其中leetcode平台的测试我并没有使用playground（因为在playground上跑代码并不能显示内存消耗），使用的是在779. 第K个语法符号题内提交代码的方式进行测试（因为本题本身想要AC所需的时间和空间几乎为0，不会对测试造成太大的时间和空间干扰）。在codeforces上直接使用custom test进行测试，很方便。除此以外，还使用可AC的启发式合并解法测试了下实际解题时的开销。

结果（跑三次取平均）

leetcode测试 (n=3210)codeforces测试 (n=3210)codeforces测试 (n=10000)leetcode实际解题
返回对象(dfs1)1877ms / 384MB390 ms / 5476 KB3961 ms / 6932 KB1111ms / 397MB
返回对象指针(dfs2)1159ms / 339MB327 ms / 115880 KBMLE928ms / 416MB
返回对象指针并释放内存(dfs3)1915ms / 384MB390 ms / 5436 KB3883 ms / 6992 KB1217ms / 436MB

结果还是很意外的，看来C++的RVO（返回值优化）确实还不错，整体来看，返回对象（dfs1）和返回对象指针并释放内存（dfs3）在两个平台上效率都差不多。但是leetcode平台不知道编译器做了什么神奇的优化，不用手动释放内存也不会MLE，而且时间消耗很明显比正常的两种写法要好。看来以后leetcode上写题如果TLE了，感觉时间复杂度没法再优化的情况下，可以尝试下返回对象指针而且不释放内存的写法。

除此以外，也能看出codeforces的判题机效率是真的好，差不多的代码和数据，居然比leetcode上跑要快这么多，难怪说codeforces把很多人养出了stl依赖症hhh。

leetcode测试代码（提交至779. 第K个语法符号）

bool flag;
class S {
public:
    vector<int> res;
    vector<int> g[100005];
    unordered_set<int> dfs1(int now, vector<int>& nums)
    {
        unordered_set<int> se;
        se.insert(nums[now]);
        for (auto v : g[now])
        {
            auto temp = dfs1(v, nums);
            // if (temp.size() > se.size()) swap(temp, se);
            for (auto e:temp) se.insert(e);
            res[now] = max(res[now], res[v]);
        }
        while (se.count(res[now])) ++res[now];
        return se;
    }
    unordered_set<int>* dfs2(int now, vector<int>& nums)
    {
        unordered_set<int>* se = new unordered_set<int>();
        se->insert(nums[now]);
        for (auto v : g[now])
        {
            auto temp = dfs2(v, nums);
            // if (temp->size() > se->size()) swap(temp, se);
            for (auto e:(*temp)) se->insert(e);
            // delete temp;
            res[now] = max(res[now], res[v]);
        }
        while (se->count(res[now])) ++res[now];
        return se;
    }
    unordered_set<int>* dfs3(int now, vector<int>& nums)
    {
        unordered_set<int>* se = new unordered_set<int>();
        se->insert(nums[now]);
        for (auto v : g[now])
        {
            auto temp = dfs3(v, nums);
            // if (temp->size() > se->size()) swap(temp, se);
            for (auto e:(*temp)) se->insert(e);
            delete temp;
            res[now] = max(res[now], res[v]);
        }
        while (se->count(res[now])) ++res[now];
        return se;
    }
    vector<int> smallestMissingValueSubtree() {
        vector<int> parents(3210), nums(3210); //如果是4000直接TLE，没法得到结果
        //构造测试数据
        iota(parents.begin(), parents.end(), -1);
        iota(nums.begin(), nums.end(), 1);

        res.resize(parents.size(), 1);
        for (int i = 0; i < parents.size(); i++)
            if (parents[i] != -1)
                g[parents[i]].push_back(i);
        
        dfs1(0, nums);
        // dfs2(0, nums);
        // dfs3(0, nums);
        return {};
    }
};
class Solution {
public:
    int kthGrammar(int n, int k) {   
        if (!flag) //leetcode会多次调用函数，弄个全局变量保证只执行一次，不然TLE
        {
            S().smallestMissingValueSubtree();
            flag = true;
        }
        return __builtin_popcount(k-1)%2;
    }
};

codeforces代码（使用custom test，GNU G++17 7.3.0）

#include <bits/stdc++.h>
using namespace std;

class S {
public:
    vector<int> res;
    vector<int> g[100005];
    unordered_set<int> dfs1(int now, vector<int>& nums)
    {
        unordered_set<int> se;
        se.insert(nums[now]);
        for (auto v : g[now])
        {
            auto temp = dfs1(v, nums);
            // if (temp.size() > se.size()) swap(temp, se);
            for (auto e:temp) se.insert(e);
            res[now] = max(res[now], res[v]);
        }
        while (se.count(res[now])) ++res[now];
        return se;
    }
    unordered_set<int>* dfs2(int now, vector<int>& nums)
    {
        unordered_set<int>* se = new unordered_set<int>();
        se->insert(nums[now]);
        for (auto v : g[now])
        {
            auto temp = dfs2(v, nums);
            // if (temp->size() > se->size()) swap(temp, se);
            for (auto e:(*temp)) se->insert(e);
            // delete temp;
            res[now] = max(res[now], res[v]);
        }
        while (se->count(res[now])) ++res[now];
        return se;
    }
    unordered_set<int>* dfs3(int now, vector<int>& nums)
    {
        unordered_set<int>* se = new unordered_set<int>();
        se->insert(nums[now]);
        for (auto v : g[now])
        {
            auto temp = dfs3(v, nums);
            // if (temp->size() > se->size()) swap(temp, se);
            for (auto e:(*temp)) se->insert(e);
            delete temp;
            res[now] = max(res[now], res[v]);
        }
        while (se->count(res[now])) ++res[now];
        return se;
    }
    vector<int> smallestMissingValueSubtree() {
        vector<int> parents(10000), nums(10000); 
        //构造测试数据
        iota(parents.begin(), parents.end(), -1);
        iota(nums.begin(), nums.end(), 1);

        res.resize(parents.size(), 1);
        for (int i = 0; i < parents.size(); i++)
            if (parents[i] != -1)
                g[parents[i]].push_back(i);
        
        dfs1(0, nums);
        // dfs2(0, nums);
        // dfs3(0, nums);
        return {};
    }
};

int main()
{
	S().smallestMissingValueSubtree();
}

leetcode实际解题代码（提交至Leetcode 2003. 每棵子树内缺失的最小基因值）

class Solution {
public:
    vector<int> res;
    vector<int> g[100005];
    unordered_set<int> dfs1(int now, vector<int>& nums)
    {
        unordered_set<int> se;
        se.insert(nums[now]);
        for (auto v : g[now])
        {
            auto temp = dfs1(v, nums);
            if (temp.size() > se.size()) swap(temp, se);
            for (auto e:temp) se.insert(e);
            res[now] = max(res[now], res[v]);
        }
        while (se.count(res[now])) ++res[now];
        return se;
    }
    unordered_set<int>* dfs2(int now, vector<int>& nums)
    {
        unordered_set<int>* se = new unordered_set<int>();
        se->insert(nums[now]);
        for (auto v : g[now])
        {
            auto temp = dfs2(v, nums);
            if (temp->size() > se->size()) swap(temp, se);
            for (auto e:(*temp)) se->insert(e);
            // delete temp;
            res[now] = max(res[now], res[v]);
        }
        while (se->count(res[now])) ++res[now];
        return se;
    }
    unordered_set<int>* dfs3(int now, vector<int>& nums)
    {
        unordered_set<int>* se = new unordered_set<int>();
        se->insert(nums[now]);
        for (auto v : g[now])
        {
            auto temp = dfs3(v, nums);
            if (temp->size() > se->size()) swap(temp, se);
            for (auto e:(*temp)) se->insert(e);
            delete temp;
            res[now] = max(res[now], res[v]);
        }
        while (se->count(res[now])) ++res[now];
        return se;
    }
    vector<int> smallestMissingValueSubtree(vector<int>& parents, vector<int>& nums) {
        res.resize(parents.size(), 1);
        for (int i = 0; i < parents.size(); i++)
            if (parents[i] != -1)
                g[parents[i]].push_back(i);
        
        dfs1(0, nums);
        // dfs2(0, nums);
        // dfs3(0, nums);
        return res;
    }
};
夜淡
关注
专栏目录
c++怎么返回对象
songjian1104的专栏
11-30 2384
返回对象，无非两种方式，返回栈对象和堆对象指针，栈对象指针不能返回，因为可能使用不该使用的内存，堆对象也不能直接返回，因为会产生内存泄漏。下面，我们分析两种返回方式的优缺点，及针对缺点的解决方案。 返回栈对象： 优点：不用手动释放内存，避免了内存泄漏； 缺点：会产生对象拷贝，如果对象比较大，比如，对象里面有大数组，会产生性能开销。 返回堆对象指针： 优点：不会产生对象拷贝，对性能友好； 缺点：函数调用之后手动释放对象，代码管理难度和内存泄漏风险提高。 那有没有办...
C++算法刷题常用库函数
Daisy_Qw的博客
05-18 2027
常用库： #include<iostream> #include<sstream> #include<vector> #include<string> #include<stack> #include<queue> #include<map> #include<set> #include<algorithm> 1.<iostream><sstream> 见：牛客网输入
C++方法返回值--类对象/类指针
quietbxj的博客
05-07 1479
返回为对象，会自动调用拷贝构造函数，效率较低； 返回对象指针，效率高；但不释放会造成内存泄漏（使用智能指针来解决）。
C++：函数返回引用或者指针
得克特
05-17 3428
C++ 有三种传递方式：值传递，指针传递，引用传递 返回**“值”和返回“引用”**是不同的 函数返回值时会产生一个临时变量作为函数返回值的副本，而返回引用时不会产生值的副本，既然是引用，那引用谁呢？ 引用一个局部变量 引用一个局部变量，是不可行的。 string& toString(const int& n) { string s; stringstream ss; ss << n; ss >> s; return s; }
函数返回什么类型好：指针还是对象
梦想庚远
07-10 1329
这个问题 困扰了 我很长时间，现在征求解答 ： 下面是模拟代码  代码1：  C/C++ codeFileElement* FolderElement::GetSingleFile(LPCTSTR fileName) const {     ......    FileElement *pFile = new FileElement(....);     .........   
C++之对象指针
weixin_30780221的博客
07-24 108
使用new关键字申请内存空间会调用构造函数 而使用malloc申请内存空间只是单纯分配空间，不会调用构造函数 转载于:https://www.cnblogs.com/xjyxp/p/11238700.html...
135-牛客网C++刷题4
weixin_45964837的博客
12-31 1226
1.C++ 中一个类可以同时继承多个基类，这种称之为多继承 2.从内存分配上看：程序为指针变量分配内存区域，而引用不需要分配内存区域 “sizeof 引用”得到的是所指向的变量(对象)的大小，而“sizeof 指针”得到的是指针本身(所指向的变量或对象的地址)的大小 指针通过某个指针变量指向一个对象后，对它所指向的变量间接操作。程序中使用指针，程序的可读性差；而引用本身就是目标变量的别名，对引用的操作就是对目标变量的操作 3.设：char w; int x; float y; double z; 则表达式:
牛客网C++刷题要点
Tsehooo的博客
08-16 1160
1.虚函数 不要在构造函数和析构函数中调用虚函数 下面说说原理： 假如基类有个虚函数 那么编译器会为其创建虚函数表vtbl 并在对象的内存空间创建虚函数指针vptr 虚函数表的原理是每个类会在里面有自己的所能调用到的虚函数地址 对象的内存空间一般只有两样东西： 虚函数指针vptr 和 数据成员（包括直接基类和间接基类的） 在对象初始化过程中 先构造基类对象再构造派生类对象 也就是说当前正在执行基类的构造函数时 执行完初始化列表之后 执行构造函数体之前 编译器插入了初始化vptr的逻辑 令对象的vptr指向是
132-牛客网C++刷题1
weixin_45964837的博客
12-29 905
1.a=35 , a4; 最终a为60.是否正确？ 答案：错误 解析：逗号表达式，依次计算，整体的值为最后结果，先计算a＝35，所以a的值是15，再计算a4，由于没有再进行赋值运算，所以a的值还是15，不过整体表达式的值是60，可以这样测试 b＝（a＝35，a4）；你会发现输出的a是15，b是60 2.输出的结果是多少个字节？ #include <iostream> using namespace std; struct Bar { char c[16]; }; struct Tes
133-牛客网C++刷题2
weixin_45964837的博客
12-30 1283
1.字符串常量是括在双引号中的，字符常量是括在单引号中的 2.在构造一个类的对象时，会自动调用其构造函数，在销毁一个类的对象时，会自动调用其析构函数 3.关于C++中的new和C语言中的malloc，以下说法是正确的是？ A.都是用来申请内存的 B.都是函数 C.都会调用构造函数 D.他们没有区别，都一样 答案：A 解析： B选项：C++中new和delete是操作符，C语言中malloc和free是函数 C选项：C语言中没有构造函数，malloc也无从调用 因为编译器无权调用库函数来执行构造函数和析构，无
C++函数的返回值是指针
文天大人
11-20 640
怀念二抱三抱
C++ 函数参数应该传递对象还是对象引用？函数应该返回对象还是对象引用？
weixin_43335392的博客
03-15 1067
在初学C++的时候，学到引用结合函数运用的部分，一直有一个疑惑：函数的参数应该是对象还是对象的引用？返回值选择返回对象还是对象的引用？二者又有什么区别？ 首先来看，函数参数方面： 记住：编写使用对象作为参数的函数时，应按引用而不是按值来传对象，原因如下 1.提高效率，按值传递（直接传递对象）涉及到生成了临时拷贝，即调用复制构造函数，然后调用析构函数，调用这些函数需要时间，比起直接传递对象的引用花费...
有关返回对象的说明和使用指向对象的指针
weixin_50866517的博客
03-02 852
当成员函数或独立的函数返回对象时，有几种返回方式可选择。可以返回指向对象的引用，指向对象的const引用或const对象。
C++ 引用与指针区别
great_emperor_的博客
02-27 324
1.引用是一个别名，指针是一个变量；变量中存储的数据是地址。 2.对指向地址变量进行操作时，引用不需要解引用；指针需要解引用（加*）。 3.引用定义时需要有明确指向，且指向一旦确定就不能改变；指针定义时指向可以为空，且中途指向可以改变。 4.++运算意义不一样，引用名++：表示引用变量的值++；指针名++：表示指向地址++。同理，sizeof(引用)返回值是引用变量开辟的大小；sizeof(指针)返回值是指针变量本身的大小，与指针指向变量类型无关。 5.引用只有一级；指针有多级。 6.引用不能被c
effective c++ ------不要返回指向局部对象指针或引用，该返回对象就返回对象.
chen
12-25 2613
首先我们来看一个例子： #include using namespace std; const int &fun1(int a,int b) { int i=0; i = a + b; return i; } int main() { if (fun1(1, 2) == fun1(2, 5)) { cout << fun1(1, 2) << endl; cout <<
C/C++ : 函数返回值为结构体，以及返回指针
最新发布
ken2232的博客
07-09 8374
目录C语言中函数如何返回结构体？C语言函数返回结构体的方法：typedef使用标准符号从函数中返回结构体：指针。
Self Summary: C++函数返回引用和指针的问题，局部对象与new对象的问题
Steven Li's Zone
07-27 4779
C++的局部对象的概念： 作用域在局部范围内（例如函数）的对象。这样的对象可以把对象的引用或者指针存在栈中，随着函数的结束而销毁，而把创建的对象内容存在堆中。如果需要在堆上创建对象，要么使用new运算符，要么使用malloc系列函数。 而关键是理解好“自动存储”的概念[1]： Object obj; 此时，obj是在栈上分配的吗？ 要回答这个问题，我们首先要理解这个语
C++含有指针成员的类对象作为函数返回值
jinxi1978的博客
04-17 2127
C++含有指针成员的类对象作为函数返回值 C++的函数内部如果声明并初始化了一个类的对象，并且在函数结束的时候要将这个对象返回，则实际的执行机制是首先调用该类的拷贝构造函数生成一个该对象的拷贝，然后返回这个拷贝，然后原始的对象会被析构。我之前一个以为是直接返回函数内部定义的变量，因此在这个过程中拷贝构造函数就显得十分重要，编译器会为我们生成一个默认的拷贝构造函数，但是当对象的类中含有指针成员的时候...
函数能否返回对象，而不是指针
疯流人物
08-05 253
现有一通用获取记录集合函数 functionGetRec(StrSql:string):Tadodataset; var rec1:Tadodataset; begin rec1:=TADODataSet.Create(nil); rec1.Connection:=ADOConnection1; rec1.CommandText:=strsql; rec1.Open; result:=rec1...
C++面向对象：返回指针值的函数解析
在C++中，返回指针的函数在设计类和对象时特别有用，比如工厂模式或单例模式。工厂模式中，函数通常会根据传入的参数创建一个对象实例，并返回这个实例的指针。单例模式中，函数确保整个程序只有一个特定类的实例，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值