小编sof*_*ver的帖子

虽然这是一个非常基本的代码,但似乎Java中存在一些根本性的缺陷,或者我用来运行代码的Eclipse IDE使用的JVM.

代码运行即使它不应该(我认为)!A.java中的代码只显示"你好,我是A!"

这里是:

import java.lang.*;
import java.util.*;
class A {   
      private void methodA() {System.out.println("Hello, I am A!");}   
      public static void main(String[] args) {   
        A a = new A();   
        a.methodA(); }   
} 

我不明白为什么在创建类A的实例后,main()成功地在该实例上运行类A的私有方法.是的,main方法属于A类,但它不是在"this"引用的上下文中从当前对象内部访问private方法.实际上,由于它是静态方法,因此无法从类中访问非静态成员.而不是main(),非静态成员方法只能从内部调用methodA().但这是另一个问题,因为我没有定义任何非静态的第二种方法.

现在谈到内部视图,让我们回到关键点,即外部视图.如您所见,main()尝试从对象外部调用methodA 并成功!为什么私人不被视为私人？

我在拉我的头发....

有人,请回复......

我正在考虑以合法的方式从授权机构获得ISO/IEC 14882:2011,而不是下载任何盗版副本.

我很困惑,在ansi.org,他们只收取30.00美元,而iso.org收费238瑞士弗兰克(= 240美元)!

由于ISO和ANSI都是授权机构,我是否应该忽略定价差异？请建议.谢谢.

我在java.lang.Object中使用wait()的定时版本,并观察到它在两种不同的场景中的行为不同.

场景1:在Thread中使用run()的默认定义

public static void main (String[] args) throws InterruptedException {
    Thread t = new Thread();    
    t.start();
    System.out.print("X");
    synchronized(t) { t.wait(10000);}
    System.out.print("Y");
}

关于scenario1的问题:我遇到了X和Y之间的延迟.这是因为我从main调用wait()(即使在t上)因此正在使用主线程的调用堆栈,而不是第二个线程？

场景2:动态 子类化线程以覆盖run()以打印内容.

public static void main (String[] args) throws InterruptedException {
     Thread t = new Thread() {public void run() 
                     {System.out.print("I am the second thread.");}};
     t.start();
     System.out.print("X");
     synchronized(t) { t.wait(10000);}
     System.out.print("Y");
}

关于场景2的问题:我没有遇到任何延迟!是什么改变只是因为我已经覆盖了run()？现在,每次我运行该程序时,它立即打印出"XI am the second thread.Y",无论如何都没有任何延迟!wait()的效果在哪里消失了？

此查询的目的是比较Java和C++的一个方面,它与"new"运算符有关.

现在,我知道在C++中有两种创建对象的方法; 有或没有"新"运算符.如果没有该运算符,则不会在堆区域中分配空间,而在存在的情况下,会在堆区域中分配空间.

Java怎么样？我注意到"new"运算符用于创建每个对象.甚至数组都是使用"new"运算符创建的.这是否意味着在Java中只存在一个对象存在的位置 - 即堆区域？

谢谢.

我遇到了一个声称是线程安全的Java类的例子.任何人都可以解释它是如何线程安全的？我可以清楚地看到类中的最后一个方法没有防止任何读者线程的并发访问.或者,我在这里错过了一些东西吗？

public class Account {
    private Lock lock = new ReentrantLock();
    private int value = 0;
    public void increment() {
       lock.lock();
       value++;
       lock.unlock();
    }
    public void decrement() {
       lock.lock();
       value--;
       lock.unlock();
    }
    public int getValue() {
       return value;
    }
}

我什至还没有开始测试，即使我正确地遵循了 GMock 的文档，我也遇到了 GMock 的 MOCK_METHOD 宏的一些语法问题。会不会是编译器的问题？我有：

MingGW (GCC 4.9.2)

谷歌测试 1.10.x

class SimpleClass {

public:
    virtual int simpleFirstFunction(int a, int b) { return (a + simpleSecondFunction(b)); }
    virtual int simpleSecondFunction(int b) { return (2 * b); }
    virtual ~SimpleClass();
};


class MockSimpleClass :public SimpleClass {
    MOCK_METHOD(int, simpleSecondFunction, (int a, int b), (override));
};

我看到 3 个编译器错误：

错误 1：关于函数名

MockSimpleClass.cpp:18:24: 错误：

'simpleSecondFunction' 不是一个类型 MOCK_METHOD(int, simpleSecondFunction(int a, int b), (override));

错误 2：关于输入参数

MockSimpleClass.cpp:18:46: 错误：

'(' token MOCK_METHOD(int, simpleSecondFunction, (int a, int …

根据我的意见，以下代码不应编译。但是，它确实可以完美打印：

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14

实际上，即使我从参数中删除了“ const”也是如此。

void arrayTest(const int size) {

    int myArray[size];
    for(int i=0; i<size; i++) {
        myArray[i] = i;
    }
    for(int i=0; i<size; i++) {
       cout << myArray[i] << " ";
    }
    cout << endl;

}


int main() {
   arrayTest(15);
   return 0;
}

我很困惑，因为我知道数组的大小是一个constexp，必须在编译时进行评估。另外，我不涉及任何类型的动态分配（即，我不使用malloc（），new等）。函数的局部变量都在堆栈上创建。无需堆参与！

那么，为什么要编译呢？

我知道每个都可以传递给另一个函数.在我看来,所有这些都像是微妙差异的替代品.

1. 函数指针:指向函数的指针

2. function object:重载了()运算符的类的实例; 能够充当一种功能;

3. lambda函数:一个匿名函数(在C++ 11中新引入),可以在现场定义,并且仅在语句的生命周期中存在

由于微妙之处,我想知道在给定场景中哪三种选择中哪一种最合适.所以,那里的专家,请一些亮点(根据一些选择标准？),以便我可以在不同的场景中决定和使用它们.

在智能指针(能够获得动态区域中的资源所有权并在使用后释放它们)出现之前,我想知道当作为参数传递给占用资源指针的函数时,动态创建的对象的簿记是如何执行的.

通过簿记,我的意思是,如果有一个"新",那么稍后在它之后应该有一个"删除".否则,程序将遭受内存泄漏.

这是一个例子,B是一个类,void a_function(B*)是第三方库函数:

void main() {

  B* b = new B(); // line1

  a_function(b);  // line2

  ???             // line3
}

我在第3行做什么？我是否认为第三方功能已经解除了内存的分配？如果没有,我认为它有,那么我的程序会遇到内存泄漏.但是,如果它取消分配b占用的内存而且我也在main()中执行它以便安全,那么b实际上最终会被释放两次!由于双重免费错误,我的程序会崩溃!

我对shared_ptr复制构造函数有些困惑.请考虑以下两行:

1. 它是对shared_ptr对象的"常量"引用,它被传递给复制构造函数,以便初始化另一个shared_ptr对象.

2. 复制构造函数也应该增加一个成员数据 - "引用计数器" - 它也在所有shared_ptr对象之间共享,因为它是一个引用某个整数的引用/指针,告诉每个shared_ptr对象它们中有多少仍然存在活.

但是,如果复制构造函数尝试增加引用计数成员数据,它是否"命中"引用传递的shared_ptr的常量？或者,复制构造函数是否在内部使用const_cast运算符临时删除参数的常量？