C++ Mutators
Author
I'm not sure if I'm using the right word here, but I think a mutator is a method that changes the caller rather than returning a modified copy. In ruby, an exclamation point is the standard way to denote that a method is a mutator. Is there any similar way to do this in C++? Of course I could invent my own way, but I was wondering if there was a standard way to do this or if anyone had a good idea.
You just give it a name that tells you what it does.
CM
struct Whatever{ void ChangeSomeValue(int i); //This is probably a mutator int ReturnSomeValue(); //This is probably an accessor};CM
The term "destructive function" would be more accurate. "Mutator" usually means something else (a method which sets the value of a field to it's argument).
Anyway, I would use references:
Although, personally, I would avoid modifying arguments where possible.
Anyway, I would use references:
#include <iostream>void f(int& i) { i = 1;}int main() { int i = 42; std::cout << i << std::endl; // Prints 1. return 0;}Although, personally, I would avoid modifying arguments where possible.
A mutator in C++ is any member function which is not declared as const. There's nothing special about the calling syntax, though.
Quote:Original post by Roboguy
The term "destructive function" would be more accurate. "Mutator" usually means something else (a method which sets the value of a field to it's argument).
Anyway, I would use references:#include <iostream>void f(int& i) { i = 1;}int main() { int i = 42; std::cout << i << std::endl; // Prints 1. return 0;}
Although, personally, I would avoid modifying arguments where possible.
You forgot the call :)
Quote:Original post by raz0rQuote:Original post by Roboguy
The term "destructive function" would be more accurate. "Mutator" usually means something else (a method which sets the value of a field to it's argument).
Anyway, I would use references:#include <iostream>void f(int& i) { i = 1;}int main() { int i = 42; std::cout << i << std::endl; // Prints 1. return 0;}
Although, personally, I would avoid modifying arguments where possible.
You forgot the call :)
Bah, good point.
Author
Quote:Original post by Sneftel
A mutator in C++ is any member function which is not declared as const. There's nothing special about the calling syntax, though.
Right, I'm merely talking about naming conventions here. Also, I'm talking about situations where the intent is ambiguous, not simply getters and setters. Here's an example:
class Vector2D{ // Does this method normalize the caller and return it // or return a normalized copy? Vector2D normalize();}With a ton of other methods like this, it would be nice to know which ones change the caller and which do not. Also, you may want one that does and does not, which would require different names to avoid ambiguity. As I said earlier, in ruby, you could name the caller-changing one normalize!() to distinguish, which is very helpful.
Well, there's quite a few clues available. First, mutators should always have a name which is an imperative statement. "Normalize!" is an order to the object. The most common convention I've seen is to have "Normalize" be a mutator, and "Normalized" return a normalized version of the unchanged vector. Secondly, as I said, mutators are non-const. On a modern IDE, this will show up when you hover over the method invocation or look in the browse window. Lastly, mutators should, in my opinion, always return void. If there's some side effect information which is produced, it should be returned by reference.
for existing code all you can really do is check if the name hints at something and if it is a void func(one arg),
for my code i usally just use the java nameing convention, though sometimes only use lowercase so i can type faster
for my code i usally just use the java nameing convention, though sometimes only use lowercase so i can type faster
class Point{int x,y;public:void setX(int X){ x=X;}int getX(){ return x;}void setY(int Y){ y=Y;}int getY(){ return y;}};Quote:Original post by Mr Awesome
With a ton of other methods like this, it would be nice to know which ones change the caller and which do not. Also, you may want one that does and does not, which would require different names to avoid ambiguity. As I said earlier, in ruby, you could name the caller-changing one normalize!() to distinguish, which is very helpful.
Returning a *copy* of the result indicates, to me, that the function returns a normalized vector. Simultaneously changing the original vector is useles, so I would not anticipate this behavior. You only ever need one or the other.
Intelligent names and parameters, const-correctness, and a little common sense will basically tell you everything you need to know.
CM
This topic is closed to new replies.
Advertisement
Popular Topics
Advertisement
