Print

Please login or register.
1 Hour 1 Day 1 Week 1 Month Forever
Login with username, password and session length

[Dutrius]

I've had a look at the C# reference, and it seems that the override is in fact unnecessary.

Having said that, the compiler complains that there is already a method called ToString if I omit the override.

"'Inventory.ToString()' hides inherited member 'object.ToString()'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword."

[Bumber]

I've had a look at the C# reference, and it seems that the override is in fact unnecessary.

Having said that, the compiler complains that there is already a method called ToString if I omit the override.

"'Inventory.ToString()' hides inherited member 'object.ToString()'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword."

Shouldn't it be something like "public string InventoryClass::ToString()"?

[Skyrunner]

Sounds trickier than it needs to be, but I can recommend the subprocess library for such tasks.

Yes, I was going to use subprocess, but I would have needed the command for python!

Thanks for sys.executable, that is indeed what I need.

[i2amroy]

Also, true and non-zero are not the same thing.

That's one of those wiggly language-based things. In at least a handful of languages (like C++), evaluating a many things (notably numbers) as a boolean is equivalent to asking "is it not zero?", so these two would be equivalent:

Code: [Select]

if (num != 0) {
    do stuff
}

if (num) {
    do stuff
}Meaning-wise they aren't the same, obviously, but implementation wise they are identical in a fair number of scenarios in a fair number of languages.

[Skyrunner]

I feel that a lot of common languages tend to implicitly convert  0 to false and 1 to true. Python does, and so do Java (i think ), C, C++, maybe C#, maybe Lua. Drfinitely PHP and Javascript.

[Reelya]

For pointers, you can just check

if(ptr)
   ptr->doThing();

and it converts not null/null to true/false. Good to know because you come across this all over the place in programs. In C# you see this to avoid errors from null references. C# reference is basically a C++ pointer.

[Bumber]

I feel that a lot of common languages tend to implicitly convert  0 to false and 1 to true. Python does, and so do Java (i think ), C, C++, maybe C#, maybe Lua. Drfinitely PHP and Javascript.

Booleans are actually just integers in C languages. C doesn't even have the bool type. 0 is False, everything else is True. Null pointers have a value of 0, and a lot of functions return 0 for various reasons.

E.g.:
if (cin)
    //no error flags, okay to read input

[TheBiggerFish]

I'm agreeing with TheBiggerFish, if he's getting at what I think he is.

You tell me, I think I completely missed the bit where it wasn't Java.
this.apply(palm, face, Math.INFINITY);
(I think.)
But yeah, I can confirm that Java has 1 be true if passed to a conditional.

In unrelated news, can I suggest that we put the language we're coding in at the top of the code section?  Just for ease of identification.
Because it took me until Right Now^TM to notice that the code I was talking about was in a language I knew nothing about.

[Rose]

C# doesn't implicitly convert null to false, though.

And C++ gives a warning when you convert int to bool.

[RoguelikeRazuka]

Hey guys where can I find some good examples that show the usage of pointers and references in C++? The cases when they're necessary, how to pass them to function, and so on?
For example, does anybody know if something is wrong with this?

Student &test(Student s) // Student is the name of a class
{
   return s;
}

and this?

Student test(Student &s)
{
   return s;
}

and this?

Student &test(Student &s)
{
   return s;
}

and this?

Student test(Student s)
{
   return s;
}

What's the difference between either of those?

[Rose]

ponters and references are, I think, the same thing.

You use them whenever you don't want to make a copy of a class, either for performance reasons, or because you want to modify the original.

[i2amroy]

The only really important difference that I know of between the two is that valid pointers can be null and valid references can't (oh, and you have to dereference pointers with '*' but you can't dereference references [which is a good example of stupid naming ]).

Beyond that they are basically the same, and in most instances compilers actually implement references internally in the end-code as a variation of a pointer.

[Reelya]

What's the difference between either of those?

Spoiler: Crash course on pass by value vs pass by reference (click to show/hide)

First up, if you need to pass in an object, make changes then return a new object (without affecting the original one), then go with the simplest set-up: Student Test(Student s) { return s; }

If you are sure you want to change the original object that was passed to you, then pass a reference, edit the referene, and have return type void.

Here's a rundown of how the pass-in parameter options work otherwise:

void Test(Student s) {}

^ This passes in a copy of the Student object. Which is slow since it has to allocate memory and call the copy constructor. But since it's a copy, you can fuck with "s" without breaking the object that was passed to you. (but if the passed object has pointers to dynamically-allocated data inside it, only the pointers get copied, not the dynamic data, so you can theoretically break the original by fucking with the dynamic data in the copy).

If you don't need to change a value that's passed to you, it's best practice to pass it in as a const:

void Test(const Student s) {}

^ this prevents accidentally changing the contents of s (in this case, the local copy of s). You might want to do that sometimes, but making things const when you don't want to change them can prevent unecessary bugs like single-equals inside if statements.

To speed things up, you can pass a reference:

void Test(Student &s) {}

Basically, it passes a memory address which is bound to the original student. But passing reference like this can be dangerous, such as if you had an error "if (s.name = "Bob"), now every Student is called "Bob" after being passed to the function.

To avoid the changing-reference error, you pass a const reference (this is best practice):

void Test(const Student &s) {}

Advantages: passed as a reference, so it's fast and efficient, but passed as a constant so you can't accidentally change the contents, too. It's not a bad idea to make this your default for passing objects around.

For your example, returning a reference is not required if you get passed the same rereference in.

void Test(Student &s) <= this function will update the student in place. there is no need to return the same reference. you take off const if you want to edit the object inside the function.

Spoiler: What's wrong in those examples (click to show/hide)

Student &test(Student s) // Student is the name of a class
{
   return s;
}

^ In this, you have a problem because the input parameter is "Student s" which is a local copy, and you're returning a reference to s. But s becomes unallocated memory after the test function ends, meaning this may cause crash bugs.

Student test(Student &s)
{
   return s;
}

^ In this, you're taking in a reference, then returning a copy. There's nothing specifically wrong with that. But you need to remember that the returned one is only a copy, so you need to treat it as such. Changing the returned copy won't affect the original Student.

Student &test(Student &s)
{
   return s;
}

^ this is passing a reference in, then returning the same thing. In this case, the returned Student is the original Student, and any changes you make to the returned copy will also change the original one.

Student test(Student s)
{
   return s;
}

^ Passing in a copy and returning another copy. Nothing much to say, except this is the slowest version because it's copying the object twice per function call.

[RoguelikeRazuka]

Now I see. But what the 'const' modifier basically means? How the complier treats an object modified with const?
Also, what are ways of passing a two-dimensional array to function?

[Reelya]

if something is const then it's a compiler error to try and change it. So a const variable parameter can only be set when a function is called, and not changed inside the function. in this case, they're still stored as normal variables, but it's just illegal to write code that tries and change them. So, const can be good to ensure a value never gets changed by accident if it shouldn't.

However, it has another use. If you write literal values into the program:

const int max_size = 256;

^ unlike a normal int, this gets compiled down to a literal value of 256 in machine code wherever it's used. Otherwise, variables are pointers which need to get dereferenced to a real value whenever they're used. So putting const for literal values like this reduces executable size and speeds up the program.

In more recent C++ versions, there's also const methods for a class:

void MyClass::MyMethod() const;

^ adding const like this means the whole method is const. For these, it's disallowed to change any values in the object within this method. It's basically a guarantee for that method that "this method is a data-retriever only, and does not change the object's state". Also, if you make two copies of the same method, one with const and one without, then for a const object, it will use the const version of the method. Which could be handy I guess, but I've never used it.