current community

your communities

more stack exchange communities

company blog
Stack Exchange Inbox Reputation and Badges
tour help
Join the Stack Overflow Community
Stack Overflow is a community of 6.6 million programmers, just like you, helping each other.
Join them; it only takes a minute:
Sign up
up vote 21 down vote favorite
2

I need to create a class whose objects can be initialized but not assigned.

I thought maybe I could do this by not defining the assignment operator, but the compiler uses the constructor to do the assignment.

I need it to be this way:

Object a=1;    // OK
a=1;           // Error

How can I do it?

share|improve this question
2  
The compiler does not use the constructor to do the assignment. It uses the constructor to create an object of type Object and then uses the assignment operator to assign that object to a. – Pete Becker 18 hours ago
    
Out of curiosity, what's the use case for this? – Chemical Engineer 13 hours ago
1  
It's difficult to explain with details, but its a "parameter transport" class compatible with almost all string types (char, std::string, CString and some other used in my programs preventing accidental overwrites. I need it because it's an old project that is very difficult to rewrite using templates. Formerly, all arguments were passed through char *, with the danger it implies. – Galaxian 12 hours ago
    
@MooingDuck -- the first line in the code requires a constructor that can be called with an argument of type int and an accessible copy constructor. But the question is about the second line, and that's what I was talking about. – Pete Becker 5 hours ago
    
@MooingDuck -- it requires a copy constructor, not a copy assignment operator. – Pete Becker 5 hours ago
up vote 35 down vote accepted

You can delete the assignment operator:

#include <iostream>
using namespace std;

struct Object
{
    Object(int) {}
    Object& operator=(int) = delete;
};

int main()
{
    Object a=1;    // OK
    a=1;           // Error
}

Alternative Solution

You can use the explicit keyword:

#include <iostream>
using namespace std;

struct Object
{
    explicit Object(int) {}
};

int main()
{
    Object a(1);    // OK - Uses explicit constructor
    a=1;           // Error
}

Update

As mentioned by user2079303 in the comments:

It might be worth mentioning that the alternative solution does not prevent regular copy/move assignment like a=Object(1)

This can be avoided by using: Object& operator=(const Object&) = delete;

share|improve this answer
up vote 44 down vote

Making a const will do the trick

const Object a=1;    // OK

Now you won't be able to assign any value to a as a is declared as const. Note that if you declare a as const, it is necessary to initialize a at the time of declaration.

Once you have declared a as const and also initialized it, you won't be able to assign any other value to a 

 a=1;   //error
share|improve this answer
8  
+1 While the other answers address what the OP asked in their paragraph, my gut says this is what they actually meant to ask. – Bear 16 hours ago
2  
And if you want it to apply to all instances of Object, use const on one (or more) of the member variables. Voila, assignment operator deleted by default. – Ben Voigt 12 hours ago
up vote 13 down vote

I hoped this would be so by not defining the assignment operator

This doesn't work because the copy assignment operator (which takes const Object& as parameter) is implicitly generated. And when you write a = 1, the generated copy assignment operator will be tried to invoke, and 1 could be implicitly converted to Object via converting constructor Object::Object(int); then a = 1; works fine.

You can declare the assignment operator taking int as deleted (since C++11) explicitly; which will be selected prior to the copy assignment operator in overload resolution.

If the function is overloaded, overload resolution takes place first, and the program is only ill-formed if the deleted function was selected.

e.g.

struct Object {
    Object(int) {}
    Object& operator=(int) = delete;
};

There're also some other solutions with side effects. You can declare Object::Object(int) as explicit to prohibit the implicit conversion from int to Object and then make a = 1 fail. But note this will make Object a = 1; fail too because copy initialization doesn't consider explicit constructor. Or you can mark the copy assignment operator deleted too, but this will make the assignment between Objects fail too.

share|improve this answer
up vote 8 down vote

How can I do it?

Option 1:

Make the constructor explicit

struct Object
{
   explicit Object(int in) {}
};

Option 2:

delete the assignment operator.

struct Object
{
   Object(int in) {}
   Object& operator=(int in) = delete;
};

You can use both of the above options.

struct Object
{
   explicit Object(int in) {}
   Object& operator=(int in) = delete;
};

Option 3:

If you don't want any assignment after initialization, you can delete the assignment operator with Object as argument type.

struct Object
{
   explicit Object(int in) {}
   Object& operator=(Object const& in) = delete;
};

That will prevent use of:

Object a(1);
a = Object(2); // Error
a = 2;         // Error
share|improve this answer
up vote 6 down vote

Deleted functions are available only from C++11 onwards, for older compilers you can make the assignment operator private.

struct Object
{
Object(int) {}
private: 
Object& operator=(int);
};

Compiler will now throw error for 

Object a=1; //ok
a=2; // error

But you can still do

Object a=1,b=2;
b=a;

Because the default assignment operator is not prevented from being generated by the compiler. So marking default assignment private will solve this issue.

struct Object
{
Object(int) {}
private: 
Object& operator=(Object&);
};
share|improve this answer

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.