标签: non-member-functions

我读到一个声明为成员函数的重载运算符是非对称的,因为它只能有一个参数而另一个自动传递的参数是this指针.所以没有比较它们的标准.另一方面,声明为a的重载运算符friend是对称的,因为我们传递两个相同类型的参数,因此可以对它们进行比较.

我的问题是,当我仍然可以将指针的左值与参考值进行比较时,为什么会选择朋友？(使用非对称版本提供与对称相同的结果)为什么STL算法仅使用对称版本？

虽然对类设计中的一些事实感到困惑,特别是函数是否应该是成员,但我查看了有效的c ++并找到了第23项,即将非成员非友元函数更喜欢成员函数.第一手阅读Web浏览器示例有一定意义,但是该示例中的便捷函数(在本书中命名为非成员函数)会改变类的状态,不是吗？

• 所以,第一个问题,他们不应该成为会员吗？

• 进一步阅读,他认为STL函数,实际上某些类没有实现的函数是在stl中实现的.继他们演变成被包装到一些合理的命名空间,如一些便利功能,这本书的想法std::sort,std::copy从algorithm.例如,vector类没有sort函数,并且使用stl sort函数,因此它不是向量类的成员.但是也可以将相同的推理延伸到向量类中的某些其他函数,例如,assign这样也不能作为成员实现,而是作为便利函数实现.但是,这也会改变对象的内部状态,例如它操作的排序.那么这个微妙但重要(我猜)问题背后的理由是什么呢？

如果你有权访问这本书,你可以为我澄清这些要点吗？

我有一个项目,我正在使用Doxygen来生成文档.这些类的文档很好,但我也有一些函数,我在main()中使用它来创建对象等.我也想将这些函数放入我的文档中,但我还没有想到如何做到这一点.有什么建议？

我对Python比较陌生,并且努力将语言的特性与我从C++和Java背景中学到的习惯相协调.

我最近的问题与封装有关,特别是Meyer的" Effective C++ " 第23项总结的一个想法:

首选非成员非友元函数到成员函数.

friend暂时忽略缺少机制,非成员函数也被认为优于Python中的成员函数吗？

一个强制的,asinine的例子:

class Vector(object):
    def __init__(self, dX, dY):
        self.dX = dX
        self.dY = dY

    def __str__(self):
        return "->(" + str(self.dX) + ", " + str(self.dY) + ")"

    def scale(self, scalar):
        self.dX *= scalar
        self.dY *= scalar

def scale(vector, scalar):
    vector.dX *= scalar
    vector.dY *= scalar

鉴于v = Vector(10, 20),我们现在可以调用v.scale(2)或scale(v, 2)加倍向量的大小.

考虑到我们在这种情况下使用属性的事实,两个选项中的哪一个 - 如果有的话 - 更好,为什么？

我正在尝试这样的事情:

Foo & operator=(Foo & to, const Bar &from);

但是我收到了这个错误:

E2239 'operator =(Foo &, const Bar &)' must be a member function

操作员可以/不能被定义为自由函数是否有限制？如果是,为什么？

拥有一个自由函数(在匿名命名空间中只能在单个源文件中访问)并将所有变量作为参数发送,而不是让私有类成员函数没有任何参数并直接访问成员变量,这有什么好处？谢谢!

标题:

 Class A {
    int myVariable;
    void DoSomething() {
       myVariable = 1;
    }
 };

资源:

 namespace {
    void DoSomething2(int &a) {
        a = 1;
    }
 }

 int A::SomeFunction() {
    DoSomething2(myVariable); // calling free function
    DoSomething(); // calling member fucntion
 }

如果您更喜欢将它们作为成员,那么如果我有一个案例,我首先调用一个不访问任何成员变量的函数,但该函数调用另一个访问成员的函数.它们既可以是会员功能还是免费的？

在阅读sbi和Eli Bendersky在这个问题中的答案后,我开始想知道静态成员函数的用途.

一个类的朋友免费功能应该不能做任何静态成员函数可以做的事情？如果是这样,为什么/何时我应该更喜欢静态成员函数给朋友免费？

正如大多数C++程序员应该知道的那样,不允许对自由函数进行部分模板特化.例如,以下是非法的C++:

template <class T, int N>
T mul(const T& x) { return x * N; }

template <class T>
T mul<T, 0>(const T& x) { return T(0); }

// error: function template partial specialization ‘mul<T, 0>’ is not allowed

然而,类/结构的模板偏特是允许的,并且可以被利用来模仿的自由功能模板偏特的功能.例如,最后一个示例中的目标目标可以通过以下方式实现:

template <class T, int N>
struct mul_impl
{
    static T fun(const T& x) { return x * N; }
};

template <class T>
struct mul_impl<T, 0>
{
    static T fun(const T& x) { return T(0); }
};

template …

Class和Namespace都有？

这个问题是关于我看到自己越来越多地使用的模式:为相关概念提供类和命名空间.我认为这主要是由C++语言工件推动的,但并非完全如此.

我认为最高级别的问题是:这是个好主意吗？同时具有相关概念的类和命名空间？

较低级别的问题:

做这个的最好方式是什么？

嵌套在命名空间中的类？:

namespace Foo_Namespace {
   class Foo_Class {
       ...
   };
}

或者是单独的,对等的,类和命名空间？:

class Foo_Class {
    ...
};
namespace Foo_Namespace {
   // non-class free functions, etc.
}

我必须承认,我倾向于在命名空间中嵌套类.即使它导致丑陋的名字.但即使我这样做,我应该使用哪些命名约定:

以下内容太长,导致名称Foo_Namespace :: Foo_Class非常难看

namespace Foo_Namespace {
   class Foo_Class {
       ...
   };
}

没有必要在名称中使用任何后缀或指示符:

namespace Foo {
   class Foo {
       ...
   };
}

但是当我看到Foo :: bar()时,我发现自己不确定,如果它是namespace :: Foo中的自由函数栏,即:: Foo :: bar(),或者名称空间中的类Foo中的成员函数::富::富::酒吧().

像:: Foo :: Foo :: bar这样的名字仍然没有,嗯,很好.

目前我在做

没有必要在名称中使用任何后缀或指示符:

namespace Foo_ns {
   class Foo {
       ...
   };
}

主要是因为我通常先创建类,然后再认识到命名空间会很好.

我想知道是否应该恢复我多年来没有使用过的命名约定:_c用于类,_ns用于命名空间: …

我曾经在一个类上工作并开始在同一个.cpp文件中编写所有内容.但是,过了一段时间我可以看到这个类越来越大,所以我决定把它分成.h和.cpp文件.

gaussian.h文件:

class Gaussian{
    private:
        double mean;
        double standardDeviation;
        double variance;
        double precision;
        double precisionMean;
    public:
        Gaussian(double, double);
        ~Gaussian();
        double normalizationConstant(double);
        Gaussian fromPrecisionMean(double, double);
        Gaussian operator * (Gaussian);
        double absoluteDifference (Gaussian);
};

gaussian.cpp文件:

#include "gaussian.h"
#include <math.h>
#include "constants.h"
#include <stdlib.h>
#include <iostream>

Gaussian::Gaussian(double mean, double standardDeviation){
    this->mean = mean;
    this->standardDeviation = standardDeviation;
    this->variance = sqrt(standardDeviation);
    this->precision = 1.0/variance;
    this->precisionMean = precision*mean;
} 

//Code for the rest of the functions...

double absoluteDifference (Gaussian aux){
    double absolute = abs(this->precisionMean - aux.precisionMean); …