标签: static-methods

我正在研究一种使用C++作为目前语言的编程语言.我正在打一个非常奇怪的回溯.

#1  0x08048d09 in factorial (n=0x8052160) at ir.cpp:35
35      shore::builtin__int * __return = NULL;
(gdb) bt
#0  shore::builtin__int::__mul__ (this=0x8052160, other=0x8052288) at /home/alex/projects/shore/shore/runtime/int.h:36
#1  0x08048d09 in factorial (n=0x8052160) at ir.cpp:35
#2  0x08048cfa in factorial (n=0x80520b8) at ir.cpp:35
#3  0x08048cfa in factorial (n=0x8052018) at ir.cpp:35
#4  0x08048d6f in main () at ir.cpp:43

具体来说,似乎声明返回的类型以某种方式触发了要调用的builtin__int 的__mul方法,我不知道为什么.builtin__int看起来像:

#ifndef _SHORE_INT_H
#define _SHORE_INT_H

#include "gc.h"


namespace shore {
    class builtin__int : public shore::Object {
        public:
            // Some day this will be arbitrary …

在静态方法覆盖的情况下..我已经开发了以下代码

class Ab {  
    static void getF() {
        System.out.println("I am saral");
    }
}

class Ham extends Ab {
    static void getF() {
        System.out.println("I am saral saxena");
    }
    public static void main(String[] args) {
        // Ham h = new Ham();
        // h.getF(); //Ham
        Ab a = new Ham();
        a.getF(); // Ab class
    }
}

现在我的查询是,当我使用多态行为时,Ab a = new Ham();在静态方法覆盖的情况下,在这个阶段我仍然得到getF();类的方法Ab,请指教.

在我用来刷新的这本书中,泛型方法和static关键字之间存在关系.似乎泛型方法需要关键字,但我不明白为什么需要它？

这是本书的作用:

 static <T> void myFunction(T [] myArray) {
     //......
 }

public class Recursive_Prob
{    
    public static void main(String[] args)    
    {    
        out.print("\f");   
        out.print(m(4));   
    }   
    public static int m(int a)   
    {   
        if (a < 0)    
            return 0;    
        else    
            return m(a-2) + n(a-1);    
    }       
    public static int n(int b)     
    {     
        if (b <= 0)    
            return 0;     
        else     
            return 1 + n(b-1);     
    }       
}    

我有一个问题,询问m在调用方法时输出是什么out.print(m(4));我尝试解决它并且出来了,0但答案是4在我运行代码时.我最终得到了m(a-2)存在0而且那部分是正确的,但使用相同的逻辑,n(a-1)也是0如此清楚我做错了什么.有人可以解释这是如何工作的？

经过几年的概念验证后,我又回到了C++.我有一个定义类的hpp文件,一个带有类方法的cpp文件和一个用于测试的main.cpp.我正在尝试创建一个在自己的线程中运行的tcp服务器(仅调用一次).我开始使用相同cpp文件中的所有代码并使其工作但是我现在得到了编译错误,因为我将类和方法放在他们自己的文件中.

我搜索过但没找到任何可行的东西.我尝试过使用extern,'singleton'等方法,这些都会导致各种错误消息.我知道我没有提供正确的方法参考.

tcpserver.hpp:

#ifndef __TCP_SERVER_HPP_INCLUDED__   
#define __TCP_SERVER_HPP_INCLUDED__   

#include <string>

class Server {
    public:

        static void *tcp_server(void * dummy);
        static void hello();
        static int parseCmd(const char *cmd, char *reply);
        static int copystring(char *reply, const char *msg);

    private:

};

#endif

tcpserver.cpp,将类方法作为存根:

#include <iostream>
#include <cstdlib>
#include <pthread.h>
#include <unistd.h>
#include <cstring>      // Needed for memset
#include <sys/socket.h> // Needed for the socket functions
#include <netdb.h>      // Needed for the socket functions
#include <string.h>

#include "tcpserver.hpp"

int Server::parseCmd(const char *cmd, char …

希望这不是与 C 中“静态”函数的含义相关的许多其他问题的重复。

我们支持一些包含以下内容的传统原生 C 代码......（不要问我为什么要重新 VOID/void）

#define VOID void
#define LOCAL static
...
VOID LOCAL vLoMyMethod();

据推测，预处理器将后者转换为

void static vLoMyMethod();

编译器（Visual Studio 2015，大概是相对普通的标志/设置，警告级别 W3）对此似乎没问题，尽管我的理解是“静态”应该出现在返回类型说明符之前，即

static void vLoMyMethod();

这些在语法上是否相同并且都正确？如果不是，为什么编译器会接受前者可能不正确的语法？

编辑 1

到目前为止，感谢您的回答。有趣的是，我不确定它们是否 100% 等效并且在所有情况下都可以接受，ala：

char * static vLoMyMethod1();   // compiler complains about expecting 'type' (intellisense wants an identifier)
static char * vLoMyMethod2();   // compiler is fine 

我正在尝试使用 Mockito 的一些新功能，特别是静态方法的模拟。

当我模拟的方法没有参数时，我可以让它工作，但由于某种原因，如果该方法有任何参数，它就不起作用。

正如下面的示例所示，测试assertEquals( "bar", Foo.foo() )有效，但测试assertEquals(2, map.size() )失败，因为没有为模拟类定义行为。

fooMock.when(Foo::genMap).thenCallRealMethod()给出以下编译时错误：

• 类型 Foo 没有定义适用于此的 genMap()
• MockedStatic 类型中的方法 when(MockedStatic.Verification) 不适用于参数 (Foo:: genMap)

fooMock.when( (String s)->Foo.genMap(s) ).thenCallRealMethod()给出这些编译时错误：

• MockedStatic 类型中的方法 when(MockedStatic.Verification) 不适用于参数 ((String s) -> {})
• Lambda 表达式的签名与函数式接口方​​法 apply() 的签名不匹配

单元测试：

@RunWith(MockitoJUnitRunner.class)
public class FooTest {

    @Test
    public void fooTest(){  
        try( MockedStatic<Foo> fooMock = Mockito.mockStatic(Foo.class) ){
            fooMock.when(Foo::foo).thenReturn("bar");
            assertEquals( "bar", Foo.foo() );
            //fooMock.when(Foo::genMap).thenCallRealMethod();
            //fooMock.when( (String s)->Foo.genMap(s) ).thenCallRealMethod();
            Map<String, String> map = Foo.genMap("1=one 2=two");
            assertEquals(2, map.size() );
        }
    } …

我将在我用 C++ 编写的项目中使用用 C 实现的驱动程序库。库的头文件包含许多声明为extern我必须实现的函数存根：

extern uint8_t ADS1x1x_i2c_start_write (uint8_t i2c_address);

我的 C++ 代码现在包含一个名为 的类vfd，该类将包含实现各自函数存根的静态方法，就像这样：

uint8_t vfd::ADS1x1x_i2c_start_write (uint8_t i2c_address) {
  uint8_t ret = 0x00;
  // do something
  return ret;
}

在类的头文件中vfd，相应的行将如下所示：

class vfd {
  public:
    uint8_t ADS1x1x_i2c_start_write (uint8_t i2c_address);
}

我应该如何声明我的方法，以便编译器将它们识别为extern我的库头文件中相应函数的实现？

首先，请看下面的代码。

package test;

class c_hi {
    public static void method_hi(){
        System.out.println("hi");
    }
}

class c_bye {
    public void method_hi(){
        System.out.println("bye");
    }
}

public class test {
    public static void main(String[] args){
        c_hi.method_hi();
        c_bye c_hi = new c_bye();
        c_hi.method_hi();
    }
}

我已经使用Java几年了，我了解命名类名和变量名的一般规则。

然而，我得到了一个非常有趣的问题。如果“c_bye”类的引用变量名为“c_hi”（已经存在名为“c_hi”的类），

我无法从“test”类内部访问“c_hi”类的“method_hi”。

当然，我知道这个问题可以通过不重叠类名和变量名、包分离、FQCN等来防止或规避。

除了通常的避免重名的方法外，还有没有更符合语法的方法来解决这个问题？请告诉我你的意见。（或者，如果我可以参考有关 Stack Overflow 的任何文档、链接或其他问题，我将不胜感激。）

此代码对 JDK 版本 8 和 15 的工作方式相同。

class Circle {
    constructor() {
        this.width = 2;
        this.height = 3;
    }
    
    static area() {
        return this.width * this.height
    }
} 

console.log(Circle.area()) // NaN

我了解到 Class 的静态方法将 this 绑定到 Class 本身，而不是 Instance 的新对象。所以我期望 Cicle.area() 返回 6，它来自 (2 * 3)。但实际结果返回 NaN。我找不到原因。