标签: member

我正在查看Java代码,LinkedList并注意到它使用了静态嵌套类Entry.

public class LinkedList<E> ... {
...

 private static class Entry<E> { ... }

}

使用静态嵌套类而不是普通内部类的原因是什么？

我能想到的唯一原因是,Entry无法访问实例变量,因此从OOP的角度来看,它具有更好的封装.

但我认为可能有其他原因,也许是表现.可能是什么？

注意.我希望我的条款正确,我会称之为静态内部类,但我认为这是错误的:http://java.sun.com/docs/books/tutorial/java/javaOO/nested.html

我正在练习使用多个文件和头文件等.所以我有这个项目需要两个数字,然后添加它们.很简单.

这是我的文件:

main.cpp中

#include <iostream>
#include "add.h"

int main()
{
    int x = readNumber();
    int y = readNumber();

    writeAnswer(x + y);

    return(0);
}

io.cpp

int readNumber()
{
    int x;

    std::cout << "Number: ";
    std::cin >> x;

    return x;
}

void writeAnswer(int x)
{
    std::cout << "Answer: ";
    std::cout << x;
}

add.h

#ifndef ADD_H_INCLUDED
#define ADD_H_INCLUDED

int readNumber();
void writeAnswer(int x);

#endif // #ifndef ADD_H_INCLUDED

错误显示在io.cpp中.确切的错误是:

有谁知道为什么会这样？谢谢.

编辑:我昨天用相同数量的文件(2 .cpp和1.h)做了一个小项目,我没有在另一个.cpp中包含iostream标题,它仍然编译并运行正常.

我有Python类,其中我在运行时只需要一个实例,因此每个类只有一次属性就足够了,而不是每个实例.如果存在多个实例(不会发生),则所有实例都应具有相同的配置.我想知道以下哪个选项会更好或更"惯用"Python.

类变量:

class MyController(Controller):

  path = "something/"
  children = [AController, BController]

  def action(self, request):
    pass

实例变量:

class MyController(Controller):

  def __init__(self):
    self.path = "something/"
    self.children = [AController, BController]

  def action(self, request):
    pass

我有一个关于php中的静态函数的问题.

我们假设我有一堂课

class test {
    public function sayHi() {
        echo 'hi';
    }
}

如果我这样做test::sayHi();没有问题.

class test {
    public static function sayHi() {
        echo 'hi';
    }
}

test::sayHi(); 也有效.

头等舱和二等舱有什么区别？

静态函数有什么特别之处？

我知道这已被问了很多次,因此很难深入研究这个问题并找到一个有效的简单例子.

我有这个,它很简单,适用于MyClass......

#include <iostream>
using std::cout;
using std::endl;

class MyClass
{
    public:
        MyClass();
        static void Callback(MyClass* instance, int x);
    private:
        int private_x;
};

class EventHandler
{
    public:
        void addHandler(MyClass* owner)
        {
            cout << "Handler added..." << endl;
            //Let's pretend an event just occured
            owner->Callback(owner,1);
        }
};

EventHandler* handler;

MyClass::MyClass()
{
    private_x = 5;
    handler->addHandler(this);
}

void MyClass::Callback(MyClass* instance, int x)
{
    cout << x + instance->private_x << endl;
}

int main(int argc, char** argv)
{
    handler = new …

我知道按定义,内联成员函数应该进入标题.但是如果不能将函数的实现放入标题呢？让我们来看看这种情况:

档案啊

#pragma once
#include "B.h"

class A{
    B b;
};

文件Bh

#pragma once

class A; //forward declaration

class B{
    inline A getA();
};

由于圆形包括我必须把实施getA成

B.cpp

#include "B.h"
#include "A.h"

inline A B::getA(){
    return A();
}

编译器会内联getA吗？如果是这样,哪个内联关键字是重要的(标题中的那个或.cpp文件中的那个)？是否有另一种方法将内联成员函数的定义放入其.cpp文件中？

在C++中,为什么private是类的成员的默认可见性,但是对于结构是公共的？

为什么我们不能初始化结构中的成员？

例:

struct s {
   int i = 10;
};

为什么以下代码有效呢？

struct A {
    std::vector<A> subAs;
};

A是不完整的类型,对吧？如果有一个A*s的矢量我会理解.但在这里,我不明白它是如何工作的.它似乎是一个递归的定义.

我见过人们在类中使用尾随下划线作为成员变量,例如在着名的C++ FAQ Lite中.

我认为它的目的不是将变量标记为成员,而是"m_"的用途.它的实际目的是使一个名为field的访问器方法成为可能,如下所示:

class Foo {
public:
    bar the_bar() { return the_bar_; }
private:
    bar the_bar_;
}

访问器省略了"get_"部分在STL和boost中是常见的,我正在尝试尽可能接近这些开发编码风格,但我不能真正看到它们使用下划线技巧.我无法在STL或boost中找到一个只返回私有变量的访问器.

我有几个问题我希望你能回答:

1. 这个惯例来自哪里？短暂聊天？Objective-C的？微软？我在想.
2. 我是否会为所有私有成员使用尾随下划线,或者只是作为一种解决方法,以防我想将函数命名为变量？
3. 你能指点我的STL或代码来演示成员变量的尾随下划线吗？
4. 有谁知道Stroustrup对这个问题的看法是什么？
5. 你能指点我进一步讨论这个问题吗？