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 )

Quote:

---

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.

Quote:

---

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.

Quote:

---

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!

Quote:

---

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.

Quote:

---

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

Quote:

---

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)

>> Is it good style to catch exceptions "far away" from the place there they get thrown?
Yes, sort of. A common error made when using exceptions is to catch the exception too close to where it is thrown.

The best place to catch an exception is wherever the best place to handle it is. In your case, invalid command line arguments should be handled in main (or the equivalent) so that the application can error out and exit.

It would seem a little weird to catch boost::bad_lexical_cast somewhere far from where you do the cast, though.

If you have multiple command line arguments to process, perhaps you can have a block of code that parses all of them and put that into it's own try/catch, but otherwise I think just leaving it where you have it (or around a main2() type function) is best.

You can even do something as silly as

Code:

---

int main()
try {
    //...
}
catch (boost::bad_lexical_cast&)
{
    cout << "exception was thrown"
}

---

But that may indeed not be a good idea if you are not throwing the exceptions yourself, as you'd lose the ability to tell exactly what went wrong (multiple lexical_casts throwing).

Why not this?

Code:

---

int main( int argc, char* argv[] )
{
  try
  {
      // Put all of the main() code in here.
  }
  catch ( whatever& e )
  {
      ...
  }
  catch ( blahblah& e )
  {
      ...
  }
  catch ( ... )
  {
      cout << "Unexpected exception caught!" << endl;
      return 1;
  }

  return 0;
}

---

Since the ultimate goal here is the parsing of command line options, why not wrap all the option variables in a single class, make them const, and have main() call a function (passing argc and argv) which validates the arguments, builds the options object and returns it? If the options do not validate properly, throw an exception.

Code:

---

class program_options
{
public:
    program_options(int unit_val, int other_val, int foo_val, ...)
        : UNIT(unit_val),
          OTHER(other_val),
          FOO(foo_val)
          ...
    {
    }

    // Since the options are const, make them public, accessible directly
    const int UNIT;
    const int OTHER;
    const int FOO;
    ...
};

program_options get_program_options(int argc, char **argv)
{
    if(options_not_valid())
    {
        throw program_option_exception();
    }
    ...
  return program_options(unit_val, other_val, foo_val, ...)
}

int main(int argc, char **argv)
{
    try
    {
        program_options opts = get_program_options(argc, argv);
        run_program(opts);
        return 0;
    }
    catch(program_option_exception e)
    {
        show_usage_message();
        exit(1);
    }
    return 0;
}

---

Thats a good solution and I'll probably try it, if I've a more complex option system to handle. for needs of heavy options parsing there's also boost::program_options. but I don't know if it is able to hold const values, too

Well, it parses and then gives you values. You can store them in consts.