Is it possible to make this int const?

Hi,

do you know any workaround to make the integer UNIT const?

Code:

	int UNIT;
	try
	{
		UNIT = boost::lexical_cast<int>(argv[2]);
	}
	catch(const boost::bad_lexical_cast&)
	{
		cout << "Usage: input_file.bmp granularity(1..inf)" << endl;
		exit(EXIT_FAILURE);
	}

It can't be declared const, because then it can't get its assignment inside the try block. And also it can't be declared inside the try-block, because then it's bound to the scope try defines.

Thank you in advance!

Not that used to messing around with try/catch, but maybe wrap the try/catch in a function. If the code in the catch block is run, then you already exit the program; if not, you can return the converted value to the caller which can immediately assign it to a const int.

Code:

int foo(char * arg)
{
    int temp;
    try
    {
        temp = boost::lexical_cast<int>(arg);
    }
    catch(const boost::bad_lexical_cast&)
    {
        cout << "Usage: input_file.bmp granularity(1..inf)" << endl;
        exit(EXIT_FAILURE);
    }
    return temp;
}

...

const int UINT = foo(argv[2]);

Maybe, maybe not? Just an idea.

it can't be a const, because you are assigning it a value inside the try.

You could perhaps do soemthing like this:

Code:

int func() {
	int UNIT;
	try
	{
		UNIT = boost::lexical_cast<int>(argv[2]);
	}
	catch(const boost::bad_lexical_cast&)
	{
		cout << "Usage: input_file.bmp granularity(1..inf)" << endl;
		exit(EXIT_FAILURE);
	}
        return UNIT;
}

...
   const int UNIT = func();
...

I'm not entirely sure that works, but I think it should.

HK_MP5 beat me to it...

--
Mats

Good idea, that should work. Thanks!

Use a const_cast<int>( UNIT )

Originally Posted by pheres

Hi,

do you know any workaround to make the integer UNIT const?

So, you want to set it initially, and then have it remain const afterward? Sounds like a typical const member of a class. You initialize it in the constructor, but after that, it can't be changed.

So, you might try wrapping the integer inside a very simple class which holds it as a const. And provide a "operator int()" method to allow it to automatically convert to int where required.

Originally Posted by cpjust

Use a const_cast<int>( UNIT )

the result did surprise me:

Code:

	const int UNIT = 0;
	try
	{
		const_cast<int>(UNIT) = boost::lexical_cast<int>(argv[2]);
                error: invalid use of const_cast with type ‘int’, which is not a pointer, reference, nor a pointer-to-data-member type
               
	}
	catch(const boost::bad_lexical_cast&)
	{
		cout << "Usage: input_file.bmp granularity(1..inf)" << endl;
		exit(EXIT_FAILURE);
	}

why is that?

I don't think you need a class or even a function. Just use two variables and initialize the constant one after you have a valid value for the first one:

Code:

	int temp;
	try
	{
		temp = boost::lexical_cast<int>(argv[2]);
	}
	catch(const boost::bad_lexical_cast&)
	{
		cout << "Usage: input_file.bmp granularity(1..inf)" << endl;
		exit(EXIT_FAILURE);
	}

	const int UNIT = temp;

>> why is that?
Because you need to cast to a reference or you cannot assign to it.

Code:

const_cast<int&>(UNIT) = boost::lexical_cast<int>(argv[2]);

I don't like that idea though, you are promising not to change UNIT, then you change it. It could screw up compiler optimizations or not work altogether.

Could another possibility be

Code:

const int UNIT = boost::lexical_cast<int>(argv[2]);

And simply catching the exception at a wider scope.

Originally Posted by Daved

>> why is that?
Because you need to cast to a reference or you cannot assign to it.

Code:

const_cast<int&>(UNIT) = boost::lexical_cast<int>(argv[2]);

I don't like that idea though, you are promising not to change UNIT, then you change it. It could screw up compiler optimizations or not work altogether.

I really started to like that const_cast idea because it utilized minimal code changes. But the compiler seems really confused:

Code:

	const int UNIT = 0;
	try
	{
		const_cast<int&>(UNIT) = boost::lexical_cast<int>(argv[2]);
	}
	catch(const boost::bad_lexical_cast&)
	{
		cout << "Usage: input_file.bmp granularity(1..inf)" << endl;
		exit(EXIT_FAILURE);
	}

gives me a warning "division by zero" on every place I divide by UNIT, so the assignment inside the try block seems not getting recognized by g++.

So I'll try Daveds solution, it's the shortest an cleanest so far in my eyes. Thanks for all that replys!

Originally Posted by Daved

I don't think you need a class or even a function. Just use two variables and initialize the constant one after you have a valid value for the first one:

Well, that only can work if UNIT is only used within that function. If it was a global, for instance, this wouldn't work.

For that matter, my solution wouldn't work if it needed to be a global. The method I'd use in that case would be to make the wrapper hold the variable as a private member, again using a conversion operator, and make some special function be a friend of the class so that it could set the value.

Originally Posted by anon

Could another possibility be

Code:

const int UNIT = boost::lexical_cast<int>(argv[2]);

And simply catching the exception at a wider scope.

Hm, what is the one step wider scope to that main declares? The global scope. But how can I catch exceptions there? probably I'd have to change the design to utilize that solution

Originally Posted by pheres

Hm, what is the one step wider scope to that main declares? The global scope. But how can I catch exceptions there? probably I'd have to change the design to utilize that solution

Or do something silly like this:

Code:

int main()
{
    try
    {
        return main2();
    }
    catch(...)
    {
    }
    return 1;
}

Actually, it's not that silly.

Is it good style to catch exceptions "far away" from the place there they get thrown?
(Thats a little off-topic, but it came to my mind after reading your last solution)