标签: overloading

我正在尝试做LD_PRELOAD所做的事情,即将Windows上的共享库或DLL文件预加载到给定程序以覆盖某些功能.

是否有LD_PRELOADWindows 的等价物？

我没有任何具体的功能.我只知道这在Linux上是可行的,我很好奇如何在Windows上完成本机DLL的重载.

请考虑以下代码段:

import java.util.*;
public class EqualsOverload {
    public static void main(String[] args) {
        class Thing {
            final int x;
            Thing(int x)          { this.x = x; }
            public int hashCode() { return x; }

            public boolean equals(Thing other) { return this.x == other.x; }
        }
        List<Thing> myThings = Arrays.asList(new Thing(42));
        System.out.println(myThings.contains(new Thing(42))); // prints "false"
    }
}

注意contains返回false!!! 我们似乎失去了我们的东西!

这个bug,当然是事实,我们不小心过载,而不是,重写,Object.equals(Object).如果我们class Thing改为编写如下,contains则按true预期返回.

        class Thing {
            final …

我重载了equals(包括==和!=),它检查两个对象是否等于,然后返回一个布尔值.

不幸的是,它打印0或1.我知道它是正确的但我无法弄清楚如何为了可读性目的打印真或假.

我甚至尝试过:

if (a.equals(b))
{
    return true;
}

return false;

但是,C++很顽固,足以输出0或1.

任何帮助,将不胜感激.

编辑 - 打印完成:

cout << "a == b is " << (a == b) << endl;

期望的输出是

a == b是真的

通过实验,我发现即使在静态上下文中,Java非静态方法也会覆盖范围内所有相同的命名方法.即使不允许参数重载.喜欢

import java.util.Arrays;    
import static java.util.Arrays.toString;

public class A {
    public static void bar(Object... args) {
        Arrays.toString(args);
        toString(args);     //toString() in java.lang.Object cannot be applied to (java.lang.Object[])
    }
}

我在规范中找不到任何相关内容.这是一个错误吗？如果不是,有没有理由实施这样的语言？

UPD:Java 6不编译此示例.问题是 - 为什么？

在这种情况下,C++如何处理函数重载？

#include <iostream>

void func(int x)
{
   std::cout << "integer";
}

void func(short x)
{
   std::cout << "short";
}

int main(void)
{
   func(3);
}

输出:整数

这是为什么？

在回答有关使用枚举的重载解析的问题时,出现了此问题.

虽然案例long long肯定是MSVC2012NovCTP中的一个错误(根据标准文本和gcc 4.7.1的测试),我无法弄清楚为什么会出现以下行为:

#include <iostream>

enum charEnum : char { A = 'A' };

void fct(char)      { std::cout << "fct(char)"      << std::endl; }
void fct(int)       { std::cout << "fct(int)"       << std::endl; }
void fct(long long) { std::cout << "fct(long long)" << std::endl; }

int main() 
{
    fct('A');
    fct(A);
}

MSVC2012NovCTP和gcc 4.7.1都同意此输出:

fct(char)
fct(int)

不A应该转换charEnum为char？为什么A被转换成int？

编辑:clang抱怨说这个电话含糊不清,这与我在下面的解释一致; 那说,如果它只被认为是潜在的类型,我仍然会发现它更直观.

两个相关的标准摘录是§7.2/ 9:

枚举器的值或未范围的枚举类型的对象通过整数提升转换为整数(4.5)

并且§4.5/ 4:

其底层类型为固定(7.2)的无范围枚举类型的prvalue可以转换为其基础类型的prvalue.此外,如果可以对其基础类型应用整数提升,则其基础类型固定的未范围枚举类型的prvalue也可以转换为提升的基础类型的prvalue.

因此, …

我知道有很多这样的问题,但我找不到适合我的解决方案.

我试图制作简单的分数计算器,而不是可以添加或减去任意数量的函数,并将答案写为减少的分数.

示例:input = 3/2 + 4/8,output = 2

我正在尝试重载运算符以实现此目的.

所以在程序中,我正在尝试开发输入,其中包含由运算符'+'或' - '分隔的分数表达式.

表达式中的分数数是任意的.

以下6行中的每一行都是有效输入表达式的示例:

1/2 + 3/4
1/2 -5/7+3/5
355/113
3    /9-21/    -7
4/7-5/-8
-2/-3+7/5

*我遇到的问题是,当我运行程序时,它有一个过载操作错误:错误:重载'operator <<'必须是二元运算符(有3个参数)*

  /Users/Spicycurryman/Desktop/ECS40/hw1/fraction.cpp:61:22: error: overloaded 'operator<<' must be a binary operator (has 3 parameters)
  ostream& Fraction::operator<<(ostream &os, Fraction& n)
                     ^
/Users/Spicycurryman/Desktop/ECS40/hw1/fraction.cpp:80:22: error: overloaded 'operator>>' must be a binary operator (has 3 parameters)
  istream& Fraction::operator>>(istream &os, Fraction& n)

我不明白为什么这是一个错误.

我的以下代码如下:

CPP文件

#include "Fraction.h"

Fraction::Fraction(int a, int b)
{

}
int Fraction::find_gcd (int n1, int …

public class TestMain {

    public static void methodTest(Exception e) {
        System.out.println("Exception method called");
    }

    public static void methodTest(Object e) {
        System.out.println("Object method called");
    }

    public static void methodTest(NullPointerException e) {
        System.out.println("NullPointerException method called");
    }

    public static void main(String args[]) {
        methodTest(null);
    }   
}

输出:调用NullPointerException方法

我有一个重载方法,分别接受Consumer和Function对象,并返回一个匹配相应的Consumer/Function的泛型类型.我认为这样会好,但是当我尝试使用lambda表达式调用任一方法时,我得到一个错误,指示对该方法的引用是不明确的.

基于我对JLS§15.12.2.1的阅读.确定可能适用的方法:似乎编译器应该知道我的带有void块的lambda与Consumer方法匹配,而带有返回类型的lambda与Function方法匹配.

我把以下无法编译的示例代码放在一起:

import java.util.function.Consumer;
import java.util.function.Function;

public class AmbiguityBug {
  public static void main(String[] args) {
    doStuff(getPattern(x -> System.out.println(x)));
    doStuff(getPattern(x -> String.valueOf(x)));
  }

  static Pattern<String, String> getPattern(Function<String, String> function) {
    return new Pattern<>(function);
  }

  static ConsumablePattern<String> getPattern(Consumer<String> consumer) {
    return new ConsumablePattern<>(consumer);
  }

  static void doStuff(Pattern<String, String> pattern) {
    String result = pattern.apply("Hello World");
    System.out.println(result);
  }

  static void doStuff(ConsumablePattern<String> consumablePattern) {
    consumablePattern.consume("Hello World");
  }

  public static class Pattern<T, R> {
    private final Function<T, R> …

在我从前一个问题的答案中提示之后编写了一些东西,我遇到了重载Scene :: addObject的问题.

重申相关位并使其自包含,尽可能少的细节:

• 我有继承对象的层次Interface,其中有FooS和BarS;
• 我有一个Scene拥有这些物品的人;
• Foos应该是unique_ptrs和Bars将shared_ptr在我的主要(由于前一个问题中解释的原因);
• 将main它们传递到Scene实例,其取得所有权.

最小的代码示例是这样的:

#include <memory>
#include <utility>

class Interface
{
public:
  virtual ~Interface() = 0;
};

inline Interface::~Interface() {}

class Foo : public Interface
{
};

class Bar : public Interface
{
};

class Scene
{
public:
  void addObject(std::unique_ptr<Interface> obj);
//  void addObject(std::shared_ptr<Interface> obj);
};

void Scene::addObject(std::unique_ptr<Interface> obj)
{
}

//void …