BOX2D - implicit conversion of NULL constant to 'bool' [-Wnull-conversion]

Issue

I am trying to compile Box2D to 64 bit version for android using android ndk

however I am getting loads of errors like this one:

andEnginePhysicsBox2DExtension/src/main/jni\Box2D/Collision/Shapes/b2ChainShape.h:111:20: warning: implicit conversion of NULL constant to 'bool' [-Wnull-conversion] m_hasPrevVertex = NULL; ~ ^~~~ false

Thats content of my b2ChainShape.h

/*
* Copyright (c) 2006-2010 Erin Catto http://www.box2d.org
*
* This software is provided 'as-is', without any express or implied
* warranty.  In no event will the authors be held liable for any damages
* arising from the use of this software.
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*/

#ifndef B2_CHAIN_SHAPE_H
#define B2_CHAIN_SHAPE_H

#include <Box2D/Collision/Shapes/b2Shape.h>

class b2EdgeShape;

/// A chain shape is a free form sequence of line segments.
/// The chain has two-sided collision, so you can use inside and outside collision.
/// Therefore, you may use any winding order.
/// Since there may be many vertices, they are allocated using b2Alloc.
/// Connectivity information is used to create smooth collisions.
/// WARNING: The chain will not collide properly if there are self-intersections.
class b2ChainShape : public b2Shape
{
public:
    b2ChainShape();

    /// The destructor frees the vertices using b2Free.
    ~b2ChainShape();

    /// Create a loop. This automatically adjusts connectivity.
    /// @param vertices an array of vertices, these are copied
    /// @param count the vertex count
    void CreateLoop(const b2Vec2* vertices, int32 count);

    /// Create a chain with isolated end vertices.
    /// @param vertices an array of vertices, these are copied
    /// @param count the vertex count
    void CreateChain(const b2Vec2* vertices, int32 count);

    /// Establish connectivity to a vertex that precedes the first vertex.
    /// Don't call this for loops.
    void SetPrevVertex(const b2Vec2& prevVertex);

    /// Establish connectivity to a vertex that follows the last vertex.
    /// Don't call this for loops.
    void SetNextVertex(const b2Vec2& nextVertex);

    /// Implement b2Shape. Vertices are cloned using b2Alloc.
    b2Shape* Clone(b2BlockAllocator* allocator) const;

    /// @see b2Shape::GetChildCount
    int32 GetChildCount() const;

    /// Get a child edge.
    void GetChildEdge(b2EdgeShape* edge, int32 index) const;

    /// This always return false.
    /// @see b2Shape::TestPoint
    bool TestPoint(const b2Transform& transform, const b2Vec2& p) const;

    /// Implement b2Shape.
    bool RayCast(b2RayCastOutput* output, const b2RayCastInput& input,
                    const b2Transform& transform, int32 childIndex) const;

    /// @see b2Shape::ComputeAABB
    void ComputeAABB(b2AABB* aabb, const b2Transform& transform, int32 childIndex) const;

    /// Chains have zero mass.
    /// @see b2Shape::ComputeMass
    void ComputeMass(b2MassData* massData, float32 density) const;

    /// Get the number of vertices.
    int32 GetVertexCount() const { return m_count; }

    /// Get the vertices (read-only).
    const b2Vec2& GetVertex(int32 index) const
    {
        b2Assert(0 <= index && index < m_count);
        return m_vertices[index];
    }

    /// Get the vertices (read-only).
    const b2Vec2* GetVertices() const { return m_vertices; }

    /// The vertices. Owned by this class.
    b2Vec2* m_vertices;

    /// The vertex count.
    int32 m_count;

    b2Vec2 m_prevVertex, m_nextVertex;
    bool m_hasPrevVertex, m_hasNextVertex;
};

inline b2ChainShape::b2ChainShape()
{
    m_type = e_chain;
    m_radius = b2_polygonRadius;
    m_vertices = NULL;
    m_count = 0;
    m_hasPrevVertex = NULL;
    m_hasNextVertex = NULL;
}

#endif

Any suggestion would be apprecieated

Solution

The warning you got here

implicit conversion of NULL constant to 'bool' [-Wnull-conversion] m_hasPrevVertex = NULL; ~ ^~~~ false

tells you, that you have bool fields that are initialized with NULL instead of an actual boolean value. For example m_hasPrevVertex and m_hasNextVertex. So the compiler tries to fix this by implicitly setting those values to false instead and by notifying you about that fact.

It's not a critical error in this case, but definitely a code smell. (Although, maybe different compilers would actually throw an error here, I'm not sure)

You can get rid of these warnings by simply initializing all your bools to either true or false, depending on your use case.

Answered By - QBrute