• Create Account

# Upon compiling with Nvidia SDK 3.3.1 - I get This Operator is not allowed as a constant expression

Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.

4 replies to this topic

### #1SIC Games  Members   -  Reputation: 617

Like
0Likes
Like

Posted 02 May 2014 - 08:29 AM

I did post about this on the NVIDIA form but never got word back. When I would include the header and library - a intellisense error shows up:

This operator is not allowed as a constant expression.

Okay, so I looked at where the issue was gerenerating from PxPreprocessing.h line:

#if !defined(PX_APPLE)
PX_COMPILE_TIME_ASSERT(PX_OFFSET_OF(PxPackValidation,a) == 8);
#endif


So I looked at the PX_COMPILE_TIME_ASSERT macro defination.

#define PX_COMPILE_TIME_ASSERT(exp)	typedef char PxCompileTimeAssert_Dummy[(exp) ? 1 : -1]


I couldn't figure it out why I couldn't just include some headers and libraries from PhysX - so I commented out the PX_COMPILE_TIME_ASSERT since I'm not using Apple only Windows.

In the future though - how would I be able to over come this issue without having to comment out? Are there some preprocessing definations I'm missing to include inside my project?

Game Engine's WIP Videos - http://www.youtube.com/sicgames88

### #2Bacterius  Crossbones+   -  Reputation: 8947

Like
1Likes
Like

Posted 02 May 2014 - 11:38 PM

I think the point is that the compile-time assertion actually is failing. Have you checked that? Note that maybe this assert was left over from an older version of the code and can be removed safely, but in any case, this kind of code is supposed to trip a compile error when the condition is not met. It won't generate a pretty error message, but it will fail the build.

The slowsort algorithm is a perfect illustration of the multiply and surrender paradigm, which is perhaps the single most important paradigm in the development of reluctant algorithms. The basic multiply and surrender strategy consists in replacing the problem at hand by two or more subproblems, each slightly simpler than the original, and continue multiplying subproblems and subsubproblems recursively in this fashion as long as possible. At some point the subproblems will all become so simple that their solution can no longer be postponed, and we will have to surrender. Experience shows that, in most cases, by the time this point is reached the total work will be substantially higher than what could have been wasted by a more direct approach.

- Pessimal Algorithms and Simplexity Analysis

### #3SIC Games  Members   -  Reputation: 617

Like
0Likes
Like

Posted 03 May 2014 - 11:30 AM

I think the point is that the compile-time assertion actually is failing. Have you checked that? Note that maybe this assert was left over from an older version of the code and can be removed safely, but in any case, this kind of code is supposed to trip a compile error when the condition is not met. It won't generate a pretty error message, but it will fail the build.

Yeah I uncommented this making it compile without the error. I should bring it up to Nvidia and check to make sure uncommenting the declaration was a safe idea. Thanks!

Game Engine's WIP Videos - http://www.youtube.com/sicgames88

### #4Mona2000  Members   -  Reputation: 604

Like
1Likes
Like

Posted 03 May 2014 - 03:30 PM

I think I've had that since switching to VS2013 (or 2012?). The assert is not failing, it's just a harmless IntelliSense false positive: you can either ignore it or comment it away.

### #5Pink Horror  Members   -  Reputation: 1204

Like
1Likes
Like

Posted 26 May 2014 - 10:30 PM

I'm about a month late to the discussion, but I think I have the answer:

PX_OFFSET_OF uses the offsetof macro.

The C++ version of the offsetof macro in Visual Studio's stddef.h has a reinterpret_cast in it.

Visual Studio 2013 Intellisense does not appear to accept reinterpret_cast in a constant expression, while Visual Studio 2012 was able to handle it just fine.

I tested this with a plain struct, and when I wrote up a similar expression with a C-style pointer cast instead of the C++ style reference cast, it had no problem with it.

It also looks like it would work if the file with that header is compiled as C instead of C++, because there is a C-style version of the macro in the header file that gets used in that case.

Anyway, I believe offsetof should be usable for this sort of thing, and the problem appears to only occur with Intellisense, not the compiler, so I would complain to Microsoft, not NVIDIA.

Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.

PARTNERS