overloading

This question already has an answer here: std::to_string - more than instance of overloaded function matches the argument list 2 answers In attempting to insert integer values into a string, I thought that my prayers were answered when I found std::to_string, but for some reason whenever I actually try to use it, Visual Studio complains about ambiguity. Here is the current incarnation of my function: string get_time_remaining (int elapsed) { string remaining; string temp_string; int time_remaining = TimeLimit - elapsed; int temp_int; temp_int = int(time_remaining / 3600); if(temp_int == 0)

I came across this today, and I am surprised that I haven't noticed it before. Given a simple C# program similar to the following: public class Program { public static void Main(string[] args) { Method(); // Called the method with no arguments. Method("a string"); // Called the method with a string. Console.ReadLine(); } public static void Method() { Console.WriteLine("Called the method with no arguments."); } public static void Method(string aString = "a string") { Console.WriteLine("Called the method with a string."); } } You get the output shown in the comments for each method call. I

If an interface specifies a property or method to return another interface, why is it not allowed for implementations of the first interface to "change" the return type into a more specific type? Let's take an example to illustrate: interface IFoo { IBar GetBar(); } interface IBar { } class Foo : IFoo { // This is illegal, we are not implementing IFoo properly public Bar GetBar() { return new Bar(); } } class Bar : IBar { } I know how to make it work, that's not my concern. I can just either: Change return type of GetFoo() to IBar , or Explicitly implement the interface and just call GetBar

No, not answered there ↑ I wonder if I should be using optional parameters in C#. Until now I was always overloading methods. But optional parameters are nice too, cleaner and less code. And I use them in other languages so I'm also used to them in some way. Is there anything that speaks against using them ? Performance is the first key point for me. Would it drop ? Example code: class Program { // overloading private static void test1(string text1) { Console.WriteLine(text1 + " " + "world"); } private static void test1(string text1, string text2) { Console.WriteLine(text1 + " " + text2); } //

I have two overloads of a function foo which take different std::function s which results in an ambiguity issue for the latter when used with the result of a std::bind . I don't understand why only this is ambiguous. void foo(std::function<void(int)>) {} void foo(std::function<int()>) {} void take_int(int) { } int ret_int() { return 0; } When using int() with a bind function I get an ambiguity error foo(std::bind(ret_int)); // ERROR With the gcc-5.1 error (and similar with clang) error: call to 'foo' is ambiguous foo(std::bind(ret_int)); ^~~ note: candidate function void foo(std::function<void

I'm just started to learn Rust and I'm wondering if there is way to overload methods. At first I created a struct and used a 'impl' to implement basic 'new' method. Then I thought to add 'new' method with some params, and I tried to use trait for that. The following code was successfully compiled but once I tried to use 'new' with params, compiler gave me an error about extra params. So how should I overload methods in Rust? pub struct Words<'a> { pub nouns: Vec<&'a str>, } trait Test<'a>{ fn new(nouns: Vec<&'a str>) -> Self; } impl<'a> Words<'a> { pub fn new() -> Words<'a>{ let nouns = vec![