相关疑难解决方法(0)

我是C++编程的新手,但我有Java经验.我需要有关如何将对象传递给C++中的函数的指导.

我是否需要传递指针,引用或非指针和非引用值？我记得在Java中没有这样的问题,因为我们只传递了保存对象引用的变量.

如果您还可以解释在哪里使用这些选项,那将会很棒.

考虑一个X具有N成员变量的类,每个类都有一些可复制和可移动的类型,以及N相应的setter函数.在C++ 98中,定义X可能如下所示:

class X
{
public:
    void set_a(A const& a) { _a = a; }
    void set_b(B const& b) { _b = b; }
    ...
private:
    A _a;
    B _b;
    ...
};

X上面类的setter函数可以绑定到左值和右值参数.根据实际的说法,这可能导致创建临时的,并会最终导致的分配副本; 因此,此设计不支持不可复制的类型.

使用C++ 11,我们可以移动语义,完美转发和通用引用(Scott Meyers的术语),通过以下方式重写它们,可以更有效和广泛地使用setter函数:

class X
{
public:
    template<typename T>
    void set_a(T&& a) { _a = std::forward<T>(a); }

    template<typename T>
    void set_b(T&& b) { _b = std::forward<T>(b); } …

根据我的理解:当你通过值传递时,函数会生成传递参数的本地副本并使用它; 当函数结束时,它超出范围.当您通过const引用时,该函数使用对无法修改的传递参数的引用.但是,我不明白为什么会选择一个而不是另一个,除非需要修改和返回参数.如果你有一个无效函数没有返回任何东西,为什么选择一个而不是另一个？

编辑:所以基本上通过const引用传递避免复制对象.那么在什么情况下复制对象好呢？我的意思是,如果它始终优化性能,为什么不一直使用const引用呢？

我想澄清价值和参考之间的差异.

我画了一张照片

所以,为了通过价值,

使用不同的引用创建相同对象的副本,并为本地变量分配新引用,以指向新副本

如何理解单词:"如果函数修改了该值,则修改也出现在调用函数的范围内,用于传递值和引用"

谢谢!

我想知道C++字符串是否被认为足够小,以便在通过值而不是通过引用传递时更高效.

你们其中一个人可以解释为什么下面这段代码不能编译吗？

#include <iostream>

using namespace std;

class Foo
{
public:
  Foo() { cout << "Foo::Foo()" << endl << endl; }
  Foo& operator=(const Foo&) { cout << "Foo::operator=(const Foo&)" << endl << endl; }
private:
  Foo(const Foo& b) { *this = b; cout << "Foo::Foo(const Foo&)" << endl << endl; }
};

int main()
{
  Foo foo;

  foo = Foo();
}

我收到的错误:

$ g++ -o copy_ctor_assign copy_ctor_assign.cc && ./copy_ctor_assign
copy_ctor_assign.cc: In function 'int main()':
copy_ctor_assign.cc:10: error: 'Foo::Foo(const Foo&)' is private
copy_ctor_assign.cc:17: …

class mystring {
 friend ostream& operator<<(ostream &out, const mystring ss) {
        out << ss.s;
        return out;
    }
private:
    string s;
public:
    mystring(const char ss[]) {
        cout << "constructing mystring : " << ss << endl;
        s = ss;
    }
};

void outputStringByRef(const mystring &ss) {
 cout << "outputString(const string& ) " << ss << endl;
}

void outputStringByVal(const mystring ss) {
 cout << "outputString(const string ) " << ss << endl;
}

int main(void) {
    outputStringByRef("string by reference");
    outputStringByVal("string by …

C++(隐式或显式)值构造函数是否应该通过value或reference-to-const接受其参数,当它需要以任何方式在其对象中存储参数的副本时？

这是我能想到的最短的例子:

struct foo {
    bar _b;
    foo(bar [const&] b) // pass by value or reference-to-const?
        : _b(b) { }
};

这里的想法是,我希望在创建foo对象时,以创建foo对象的各种方式最小化对bar的复制构造函数的调用.

请注意我对copy elision和(Named)返回值优化有一点了解,我读过"想要速度？通过值传递",但我不认为这篇文章直接针对这个用例.

编辑:我应该更具体.

假设我无法知道sizeof(bar),或者是否bar是基本的内置类型(bar可能是模板参数,foo可能是类模板而不是类).另外,不要假设foo构造函数可以内联(或者bar就此而言).假设我至少可能使用实现RVO的编译器.

我想是为了有一个可能性(因为编译器优化),像这样的通话将调用没有调用bar"(S执行时甚至拷贝构造函数凡_b(b)在foo的初始化列表)":

foo f = function_that_creates_and_returns_a_bar_object_using_rvo();

是否有可能(鉴于C++ 98标准)可以这样做,如果是这样,如果foo通过引用而不是值接受其参数,它或多或少可能工作？

考虑以下 :

int increment1 (const int & x)
{ return x+1; }

int increment2 (const int x)
{ return x+1; }

我理解传递对类对象的引用,但是我想知道是否值得将引用传递给简单类型？哪个更优化？通过引用传递或通过值传递(在simle类型的情况下？)

foo和bar之间有区别吗:

class A
{
  Object __o;

  void foo(Object& o)
  {
    __o = o;  
  }

  void bar(Object o)
  {
    __o = o;
  } 
} 

据我了解,foo在调用对象o时不执行复制操作,并且对赋值执行一次复制操作.Bar在调用对象o时执行一次复制操作,而另一个用于赋值.所以我或多或少会说foo使用的内存比bar少2倍(如果o足够大).那是对的吗 ？

是否有可能编译器优化bar函数以仅对o执行一次复制操作？即使__o指向参数o的本地副本而不是创建新副本？

将参数传递给将在短时间内调用数百万次的函数和方法时,传递所述参数的开销开始显示.

void foo(const SomeType&st){...}

对于像std :: string,std :: vector等类型...规则是通过引用传递,以便不会发生无意义的副本.然而,当处理诸如双打,英特等的POD时,故事却完全不同.

关于性能,如果函数/方法不需要改变参数,在决定是否应该通过引用,const引用或复制传递时,常见的"需要注意的事项"是什么？

void foo1(SomeType& st)
{
   ...
}

void foo2(const SomeType& st)
{
   ...
}

void foo3(SomeType st)
{
   ...
}

void foo4(SomeType* st)
{
   ...
}

• 是否应该通过副本传递int/unsigned int？
• 是否应该只在64位或更高目标上通过副本传递double？
• 如果函数可以内联 - 参数如何在物质中传递？
• 当通过ref/const ref传入时,别名如何影响问题？
• 在什么情况下,参数的显式副本在堆栈上是有益的？

注意:这不是关于const正确性的问题.还在32/64位平台上寻找与gcc和msvc相关的答案.

一些可能相关的问答:

"const T&arg"与"T arg"

/sf/answers/149747811/

在C++中通过引用/值传递

为什么传递const引用而不是值？