返回对成员变量数据的引用的开销
是指在编程中，获取成员变量的引用所需的资源和时间成本。
在传统的编程语言中，获取成员变量的引用通常需要通过访问对象的内存地址来实现。这涉及到了指针操作和内存访问，因此会产生一定的开销。具体的开销取决于编程语言和编译器的实现方式，以及硬件的性能。
然而，在现代编程语言和编程框架中，为了提高性能和开发效率，通常会提供更高级的语法和特性来简化成员变量的访问。例如，许多面向对象的语言提供了属性（property）的概念，可以通过简单的语法来访问成员变量，而无需直接操作内存地址。这样可以减少开销并提高代码的可读性和可维护性。
在云计算领域，返回对成员变量数据的引用的开销通常是微不足道的，因为云计算平台通常会提供高性能的硬件和优化的软件环境。此外，云计算平台还提供了各种服务和工具，可以进一步简化开发过程，提高开发效率。
对于优化成员变量引用的开销，腾讯云提供了多种产品和服务，例如：
- 云服务器（Elastic Compute Cloud，简称 CVM）：提供高性能的虚拟服务器实例，可用于部署和运行各种应用程序。 链接：https://cloud.tencent.com/product/cvm
- 云函数（Serverless Cloud Function，简称 SCF）：无需管理服务器即可运行代码的事件驱动计算服务，可用于快速构建和部署应用程序。 链接：https://cloud.tencent.com/product/scf
- 云数据库 MySQL 版（TencentDB for MySQL）：高性能、可扩展的关系型数据库服务，可用于存储和管理应用程序的数据。 链接：https://cloud.tencent.com/product/cdb_mysql
- 云存储（Cloud Object Storage，简称 COS）：安全、稳定、低成本的对象存储服务，可用于存储和管理大规模的非结构化数据。 链接：https://cloud.tencent.com/product/cos
请注意，以上产品仅作为示例，具体的选择取决于应用程序的需求和场景。在实际开发中，建议根据具体情况选择适合的腾讯云产品和服务。
相关·内容
4回答
在C++中选择返回类型
、、、、
在C中，我认为没有引用，因此返回值可以是指针，也可以是数据类型本身。如果是局部变量，则返回指针没有任何意义。如果动态分配变量，则只能返回指针。
然而，在C++中，有一个新的选择，即参考。如果我想返回的是一个局部变量，我认为我只能选择返回本身，因为在函数返回之后，其他两个变量没有什么可引用或指向的。如果我动态地分配一个变量，我会返回什么？指针还是参考？优点和缺点是什么？为什么不直接返回变量呢？
一个非常简单的例子：
class TreeNode
{
//......May be some elements and functions.
}
TreeNode& test()
{
Tr
浏览 3提问于2014-03-11得票数 0
回答已采纳
我有一个简单的活动，包含4个视图定义在一个xml文件中。出于性能的考虑，是通过他们的id访问我的视图还是让成员在我的活动中引用它们更好？它有显著的不同吗？
谢谢
浏览 0提问于2012-09-05得票数 1
回答已采纳
我已经编写了一个Node类的成员函数来读取后缀顺序的节点树。
它将由作为树的根节点的Node实例调用。
所以: N.postfix()；
这些似乎是illeagal：
*this->left.postfix();
*this->right.postfix();
这样做的正确方法是什么？
class Node
{
public:
const char *cargo;
int depth;
Node *left;
Node *right
void Node::postfix()
{
if (this==__nullptr)
{
浏览 0提问于2010-05-04得票数 1
回答已采纳
我有一个关于设置值的两种可能性的问题：
假设我得到了一个我想要更改的类的字符串。我使用的是：
void setfunc(std::string& st) { this->str = st; }
另一个函数可以完成完全相同的操作，但使用字符串引用而不是void来设置值：
std::string& reffunc() { return this->str; }
现在，如果我要设置一个值，我可以使用：
std::string text("mytext");
setfunc(text);
//or
reffunc() = text;
现在我的问题是，它是否被
浏览 0提问于2016-01-30得票数 3
1回答
C++单例代码如下所示：
MyClass& MyClass::getInstance(){
static MyClass instance;
return instance;
}
专门看static MyClass instance;
每次调用instance时是否都会创建一个新的getInstance？
编辑
我知道静态会员是每班一人。但是，每次调用static MyClass instance时，getInstance()不是都会重新声明(并因此重新创建)“单个”实例instance吗？
浏览 3提问于2021-12-21得票数 -3
回答已采纳
2回答
我正面临着以下问题:我必须为成千上万的GUI元素命名。如果它能像下面这样运行脚本就好了：
JMenuItem myMenuItem = new JMenuItem();
myMenuItem .setName(this.getClass().getSimplename() + "." + myMenuItem .get??)
如果我可以将元素的名称设置为"Classname.myMenuItem“，那就更好了。
有没有办法获得变量的名称(变量名ofc，而不是JMenuItem.getName())？
浏览 1提问于2016-02-12得票数 1
例如，如果类的成员函数是：
const QStringList& getList() const
返回整个列表可能是一项昂贵的操作，但我也不希望函数能够更改类的私有成员变量。我对这个很好奇。
浏览 1提问于2020-05-10得票数 0
回答已采纳
3回答
D成员函数属性
、、
考虑：
class B
{
public:
int i = 4;
}
class A
{
public:
B b;
this()
{
b = new B;
}
ref B f()
{
return b;
}
}
成员函数f前面的ref存储类是多余的，对吗？类对象总是通过引用传递，所以返回B和ref B是等价的吗？
第二：pure成员函数？纯函数是只返回依赖于参数的内容。因此，它不应该依赖于类的任何数据成员，因为即使是传入的相同参数，它们也可能更改函数的输出。因此，pure成员函数也是stati
浏览 6提问于2011-12-26得票数 3
回答已采纳
4回答
传递引用的开销是多少？
、、、、
当相关的getter返回引用时，访问成员变量的开销有多大？
例如，如果您有一个需要经常使用此类访问器的类，那么将所述引用存储在需要使用它的类中并只需初始化它一次会有多大的效率？
浏览 0提问于2011-11-24得票数 7
回答已采纳
假设我有一个函数，它创建一个动态函数并返回它。
Function接受String类型的数据参数并返回String。
/**
* @param {String} data
* @returns {???}
*/
const foo = data => {
let functionString = 'return data;'
return Function('data', functionString)
}
我希望它以一个适当的定义出现在VSCode Intellisense中。如何在JSDoc中记录它？
浏览 7提问于2017-02-28得票数 0
回答已采纳
我有一个安卓活动BrowseActivity加载大约3000条记录(@约100字节)从数据库到内存中，并在ListView中显示它们。在AVD中加载大约需要3到6秒，这是很好的。
当我想要从这个BrowseActivity中启动一个新的活动时，问题就出现了。它需要大约30秒，即使只是打开最琐碎的活动。Dalvik VM似乎出于未知的原因进行了大量的垃圾收集。请检查下面的logcat输出。
01-30 02:06:27.025: D/dalvikvm(553): GC_FOR_MALLOC freed 3889 objects / 221200 bytes in 45ms
01-30 02:06
浏览 3提问于2013-01-30得票数 3
1回答
我希望这是一个连贯的问题..。我有一个单例类的定义，比如：
#include A.h
class Singleton
{
public:
// If I change this to a return by pointer, it works fine. But reference gives me problems.
static Singleton &getInstance();
Singleton(Singleton const&) = delete;
void operator=(Singleton const&) = delete;
浏览 0提问于2019-05-26得票数 0
回答已采纳
3回答
关于为什么需要从函数返回引用的问题。
如果我们在line9和line16中将int&替换为int，则以下代码的行为完全相同。
在我的示例代码中，返回引用与值是不是真的？在什么样的例子中，它将开始变得重要？
在我看来，我们不能返回函数的局部变量的引用，因为局部变量将超出调用者的作用域。因此，只需要返回调用者可以看到的变量引用(在作用域中)，但如果函数的调用者可以看到该变量，则不需要返回该变量(？)(或者这样做是为了保持代码的整洁？)
相关链接：
#include <iostream>
using namespace std;
class myClass{
private:
浏览 0提问于2013-04-06得票数 4
回答已采纳
如果_map是std::unordered_map类型的成员，那么从函数中返回对 _map.find(k)->second的引用是安全的，还是这种未定义的行为(或者只是糟糕的做法)？
它似乎像预期的那样工作，但感觉就像返回一个临时引用一样。我不确定这是真的，还是可能会有其他意想不到的后果。
#include <unordered_map>
class Container
{
public:
using Key = int; // or something more interesting
// ++++++++++++++++++++++++++++++++
浏览 3提问于2015-08-19得票数 4
回答已采纳
我是java的新手，实际上是编程领域的新手，并且对类和对象感到困惑。为什么我们需要一个类来创建一个对象？这些物体是如何以及何时发现物理现实的？为什么我们需要创建一个物理事物的软件模型？这些对象和类存储在哪里？请帮帮忙。我翻看了10+网站和4本书，看不清楚。
浏览 2提问于2014-01-09得票数 1
2回答
我有class car，我在class App中使用car作为属性。
class Car{
private:
string color;
public:
//setter getter
void setColor(string c){
color = c;
}
string getColor(){
return color;
}
}
和
class App(){
private:
Car car;
public:
App():car(){
}
Car getCar(){
return car;
}
}
这是我
浏览 0提问于2018-02-27得票数 2
回答已采纳
通过引用返回向量元素是不好的做法吗？
class X{
vector<Y> v;
public:
Y& getRefFromVectorOfY(unsigned int index){
retrun v.at(index);
}
void addToVectorOfY(Y y){
v.push_back(move(y));
}
};
虽然这是有效和干净的，但问题是它破坏了封装。如果v是向量，并且是类的私有成员，调用方现在将有一个引用到私有向量中的元素，这些元素不仅可以读取，而且可以分配给(覆盖)。
能做到这一
浏览 0提问于2018-03-05得票数 1
回答已采纳
4回答
更改构造函数中的初始化顺序
、、、、
class a
{
public:
a() : b(5), a1(10) //will firstly initialize a1 then b, so order here doesn't matter
int a1;
private:
int b;
}
问题是如何改变顺序(在a1之前初始化b)？我必须让公共成员高于私有成员，所以这个解决方案对我来说是不好的。当然这里我用的是整数，这个问题比较复杂，但这只是一个例子，说明了我的问题所在。
浏览 0提问于2013-01-28得票数 1
回答已采纳
2回答
对某个java命令的解释
、、、
System.out.println(((Window)this).size);
假设我们有一个类窗口，上面的命令是在子类中的方法中编写的。我需要一些帮助，了解(窗口)这到底是干什么的。它所指的地方。
浏览 2提问于2015-03-15得票数 1
回答已采纳
1回答
请考虑这一点：
public class A
{
private B bMemeber;
private Properties myProperties;
}
和
public class B {
private Object field;
public void setField(Object o){...}
}
我有一个方面
@After("execution(* B.setField(..)) &&! within(PropertiesAspect)")
public void afterSetField(JoinPoint
浏览 4提问于2015-08-14得票数 1
回答已采纳
在代码片段中，我能够访问类作用域之外的私有成员变量。虽然不应该这样做，但为什么在这种情况下是允许的呢？通过引用接收返回的私有变量是一种错误的做法吗？
#include <iostream>
#include <cstdlib>
class foo
{
int x;
public:
foo(int a):x(a){}
int methodOne() { return x; }
int& methodTwo() { return x; }
};
int main()
{
foo obj(10
浏览 0提问于2011-01-16得票数 14
回答已采纳
3回答
我是C/C++新手，所以大家原谅我，如果这是个菜鸟的问题。
我有一个控制器类，它有一个私有成员变量，即vector<Contact> contacts。该类具有允许我们更改该向量状态的方法(标准CRUD操作)。
该类有一个名为get_contacts()的公共方法，它返回这个对象的私有向量：
std::vector<Contact> Contacts_Controller::get_contacts() const {
return this->contacts;
}
我有一个方法，它通过contact将push_back()添加到这个私有向量中。问题是，
浏览 2提问于2013-12-04得票数 0
回答已采纳
让我们来看看这个非常简单的类型：
type Test() =
let mutable myBool = false
member this.SetBool(value) =
myBool <- value
member this.GetBool() =
myBool
布尔myBool是实例的一部分，但是，它不是由“this”引用的，但是成员必须被“this”引用。
因此，在我看来，有3种情况涉及2种情况：
静态数据/方法，其中数据/方法不是“this”的instanceprefixed的一部分，其中数据/方法是不以“this”
浏览 2提问于2020-02-26得票数 0
回答已采纳
7回答
来自C#背景的我或多或少对C++中返回方法处理的怪异行为感到困惑。我现在关注的是C++中的方法，通过引用返回并不是一种非常有用的技术，这是因为--与C#不同--在方法体中声明的任何变量一旦控件退出该方法就会超出范围。
因此，在C++中，甚至不能编译(但是C#中的等效版本可以编译)：
int& DoubleValue(int nX)
{
int nValue = nX * 2;
return nValue; // return a reference to nValue here
} // nValue goes out of scope here
通过引用返回的唯一有用
浏览 2提问于2011-01-24得票数 7
回答已采纳
从类方法返回引用的最佳实践是什么？是否存在这样的情况:您希望返回不带引用的基本类型，而希望通过引用返回类对象。任何你推荐的文章，最佳实践文章。
浏览 0提问于2009-01-30得票数 11
1回答
我有这样的代码：
For i = 0 To .Fields.Count - 1
Set qc = qcolumns(i)
If qc.XlGrouped = True Then
...
对我来说奇怪的是，如果我将qc.XlGrouped = True改为qcolumns(i).XlGrouped = True，它将需要200ms，而第一个需要0ms。为什么只是将类从数组设置为变量会有这样的区别？
浏览 11提问于2019-10-23得票数 1
回答已采纳
我看到在一些程序中，为了获得更好的性能，建议使用public变量而不是get和set函数。我知道这被认为是一种糟糕的做法。我还知道编译器可以使get和set inline。这不是意味着它们的行为就像一个没有性能影响的变量吗？
浏览 3提问于2013-01-17得票数 1
回答已采纳
这是问题所在。我编写此函数是为了返回对成员向量的i元素的引用，以便可以编辑此元素。代码如下：
Letter& Literal::get (int i) const {
return lit_m.at (i); //Vector of Letter objects
}
但是g++不允许我将该元素赋值给非常数引用：
g++ -o literal.o -c literal.cpp
literal.cpp: In member function ‘Letter& Literal::get(int) const’:
literal.cpp:34: error: invalid i
浏览 2提问于2010-10-20得票数 1
4回答
给定以下代码：
#include <iostream>
#include <string>
using namespace std;
class A
{
private:
string m_name;
string m_first;
public:
A(): m_first("string") {}
virtual void print() const {}
string& getName() const {return m_first;} // won't compile
const
浏览 0提问于2011-08-29得票数 5
int& returnC() {
return c;
}
所以我的部分问题已经被另一个问题回答了，但我还是有点困惑。所以我知道这会返回引用而不是地址。但是，这个定义的优点是，您只是返回c为什么不将其定义为：
int returnC() {
return c;
}
如果它们都返回相同的变量，返回对int的引用，而不仅仅返回int的好处是什么？
如果我这样声明会怎么样：
int& returnC() {
return &c;
}
谢谢!
浏览 3提问于2014-03-06得票数 0
回答已采纳
2回答
在Effective C++ (第18项:使接口易于正确使用和难以错误使用)中，我看到了一个类似以下内容的代码示例：
class Month
{
public:
static Month Jan()
{
return Month(1);
}
static Month Feb()
{
return Month(2);
}
//...
static Month Dec()
{
return Month(12);
}
private:
explicit Mo
浏览 0提问于2012-07-07得票数 3
回答已采纳
可能重复：
这是正确的，类成员函数比简单函数花费更多的时间吗？如果使用继承和虚拟函数怎么办？
我尝试将我的函数收集到一个简单的接口类中(只有成员函数，没有数据成员)，似乎我浪费了时间。有办法修复它吗？
我正在检查gcc和icc编译器，并使用-O3选项。
浏览 8提问于2011-12-12得票数 6
回答已采纳
2回答
我有一个向量作为"B“类的成员。它有自己的set和get函数：
setVector(vector<A*>)
getVector()
我感兴趣的是从另一个使用这个类"B“的对象的函数填充这个向量。因此，我创建了"A“类的新对象，并错误地更新了"B”类的向量成员变量：
A* obj = new A;
B b;
B.getVector().push_back(obj);
发生的情况是push_back没有工作。换句话说，当我尝试使用调试器查看成员变量时，我发现向量成员变量的容量仍然为0，就好像我没有对它执行任何push_back操作一样。
我尝试将我的实现
浏览 0提问于2019-10-27得票数 0
我意识到创建、分配、复制和销毁std::tr1::shared_ptr或boost::shared_ptr (由于引用计数机制)会对性能造成影响(有时影响很大)。在构造之后，访问由shared_ptr包装的指针没有性能损失，这是正确的吗？
换句话说:给定
std::tr1::shared_ptr<myClass> SharedA(new myClass);
myClass *NakedA = new myClass;
有吗？
SharedA->someClassMember
具有相同的开销
NakedA->someClassMember
浏览 3提问于2011-05-19得票数 3
回答已采纳
4回答
class Currency
{
public:
explicit Currency(unsigned int value);
// method form of operator+=
Currency &operator +=(const Currency &other); // understood!
...
};
下面的代码显示了使用操作符的免费函数版本的等效API：
class Currency
{
public:
explicit Currency(unsigned int value);
...
};
// free
浏览 2提问于2011-12-14得票数 4
回答已采纳
在C++ OpenCV项目中，我正在处理几个函数，使用本地Mat (和UMat)变量作为内部计算的临时缓冲区。
我希望防止这些函数在每次调用它们时为它们的所有本地Mat变量分配内存。这样做的目的不是使用较少的内存，而是确保内存在第一次调用时可用或失败，并防止由于内存分配而造成的任何可能的开销。
为了防止重新分配，我考虑将本地Mat变量声明为静态变量，并确保它们总是在函数中存储相同的数据大小和类型，尽管我不关心将它们存储在多个调用中的数据。
这种方法有意义吗？我是不是做错了，还是有一个更好/更安全的方法？
浏览 3提问于2018-08-31得票数 1
回答已采纳
例如，这是我实现的向量：
template<typename T, /*...*/>
class List {
private:
/*...*/
int count;
int capacity;
public:
/*constexpr int Count() noexcept {
return count;
}*/
/*constexpr int Capacity() noexcept {
return capacity;
}*/
const int& Count = cou
浏览 5提问于2020-09-14得票数 4
回答已采纳
2回答
// declare a class with private variable “int * _a”
// declare a function of this class, foo()
Void foo() {
int * _a; // 1. Does this re-declaration then make _a equal to an unknown value?
// 2. Does a go out of scope after foo() returns?
}
浏览 2提问于2010-11-06得票数 1
回答已采纳
2回答
例如，在这个例子中，我对this指针不是很理解，这个问题不是关于operator+重载，而是关于this指针，以及它与类之间的关系，
*这个指针指向什么东西？
非常感谢！
class Integer {
int i;
public:
Integer(int ii): i(ii) { }
const Integer operator+(const Integer& rv) const {
cout<<"operator+"<<endl;
}
浏览 0提问于2012-04-07得票数 1
回答已采纳
5回答
当返回函数的作用域消失，其var一旦返回var时，我们如何通过引用返回变量？
如果我们采取以下措施来避免这种情况：
int fr = 9;
int& foo() {
//const int& k = 5;
return fr;
};
我会问，我们必须将返回的var声明为全局变量吗？
浏览 0提问于2018-05-20得票数 2
回答已采纳
我是Android的新手，我一直在读到内存管理在那些内存有限的应用程序中非常重要。
我读到过一些活动的findViewById()非常昂贵的地方。因此，我想知道，存储将用作全局变量的视图并重用对象是否是一种好的做法？还是每次需要使用视图时都运行findViewById()更好？
谢谢，凯文
浏览 0提问于2013-05-24得票数 3
回答已采纳
据我所知，作为C++的新成员，两人都打算公开一个私有成员。可以这样说：
// Make everything outside can see value of name
object.get_name(); // get method
object.name(); // return member by ref to get
// Make everything outside can set value of name
object.set_name("Name"); // set method
object.name() = "Name"; //
浏览 13提问于2015-03-21得票数 0
举个例子：
inline string &GetLabel( ) {
return m_Label;
};
其中m_Label是私有类成员变量。
我认为我理解它的方式是，这个函数将返回对变量m_Label的引用。在我的整个程序中使用它会有什么影响?只返回值而不是引用会更好吗？谢谢!
浏览 2提问于2011-12-23得票数 12
回答已采纳
我的问题是，getter方法可以返回包装器数据类型吗？会不会违反封装原则？为什么不行？类的不变性是封装的一部分吗？
public class TestGetter{
private Integer a;
public TestGetter(int _a){
a = _a;
}
public Integer getA(){
return a;
}
}
在一些客户端代码中：
TestGetter tg = new TestGetter(5);
Integer corruptX = tg.getA();//This should return the reference
浏览 2提问于2012-01-07得票数 0
回答已采纳
我是c++中的指针和引用的新手，所以我想知道是否有人可以给我一个例子，告诉我如何写一个返回字符串引用的函数，以及可能正在使用的函数。例如，如果我想要编写一个函数，比如...
//returns a refrence to a string
string& returnRefrence(){
string hello = "Hello there";
string * helloRefrence = &hello;
return *helloRefrence;
}
//and if i wanted to use to that f
浏览 0提问于2012-09-09得票数 0
1回答
我想要实现一个与C#的属性等价的、根本不使用C宏的C++。我创建了一个模板，该模板基本上以get()和set()更理想的方式设置或检索内部值。构造函数中还有两个std::function类型的参数，可以覆盖默认的getter和setter方法。
template<typename T>
class Property
{
public:
Property(T initialValue, std::function<void(T&)> setter, std::function<T&()> getter)
{
Value = i
浏览 1提问于2019-12-14得票数 1
回答已采纳
我的应用程序中有以下代码。为什么我们要在返回类型和方法名之后使用const关键字？
const T& data() const { return data_; }
浏览 2提问于2013-05-09得票数 66
回答已采纳
3回答
我想知道在调用这个异步方法之后，它是否会改变对象参数的数据。
public async Task AsyncMethod(ExampleObject obj)
{
obj.number = 10;
}
public class ExampleObject
{
public int number = 0;
}
static void Main(string[] args)
{
ExampleObject obj = new ExampleObject();
AsyncMethod(obj);
Console.WriteLine(obj.number);
浏览 10提问于2021-12-14得票数 2
2回答
我用二维数组创建了一个名为矩阵的类。我可以使用构造函数、复制构造函数和析构函数运行它。当我引入一元否定运算符时，我会得到一个运行时错误。
#ifndef MATRIX_H
#define MATRIX_H
class Matrix
{
public:
Matrix(int rSize=3, int cSize=3);
Matrix(const Matrix& m);
~Matrix();
bool setValue(int rSize, int cSize, int value);
bool getValue(int rVal, int cVa
浏览 0提问于2013-12-06得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
云直播活动推荐
腾讯云开发者
