title: 'this' cannot be used in a constant expression error (C++) with this-> pointer variable
body: <p>I am getting this error message and I know it's because the argument in the array must be constant, but I am not sure how to arrange my 'this-> V; to be constant. Any help? I provided mostly code so that the function of the pointer variable could be evident throughout the program.</p>
  
  <pre><code>// A class that represents an undirected graph
  class Graph
  {
  int V;    // number of vertices
  list&lt;int&gt; *adj;    // A dynamic array of adjacency lists
  int *in;
  public:
  // Constructor and destructor
  Graph(int V);
  ~Graph() { delete[] adj; delete[] in; }
  
  // function to add an edge to graph
  void addEdge(int v, int w) { adj[v].push_back(w);  (in[w])++; }
  
  // Method to check if this graph is Eulerian or not
  bool isEulerianCycle();
  
  // Method to check if all non-zero degree vertices are connected
  bool isSC();
  
  // Function to do DFS starting from v. Used in isConnected();
  void DFSUtil(int v, bool visited[]);
  
  Graph getTranspose();
  };
  
  Graph::Graph(int V)
  {
  this-&gt;V = V;
  adj = new list&lt;int&gt;[V];
  in = new int[V];
  for (int i = 0; i &lt; V; i++)
      in[i] = 0;
  }
  
  /* This function returns true if the directed graph has an eulerian
  cycle, otherwise returns false  */
  bool Graph::isEulerianCycle()
  {
  // Check if all non-zero degree vertices are connected
  if (isSC() == false)
      return false;
  
  // Check if in degree and out degree of every vertex is same
  for (int i = 0; i &lt; V; i++)
      if (adj[i].size() != in[i])
          return false;
  
  return true;
  }
  
  // A recursive function to do DFS starting from v
  void Graph::DFSUtil(int v, bool visited[])
  {
  // Mark the current node as visited and print it
  visited[v] = true;
  
  // Recur for all the vertices adjacent to this vertex
  list&lt;int&gt;::iterator i;
  for (i = adj[v].begin(); i != adj[v].end(); ++i)
      if (!visited[*i])
          DFSUtil(*i, visited);
  }
  
  // Function that returns reverse (or transpose) of this graph
  // This function is needed in isSC()
  Graph Graph::getTranspose()
  {
  Graph g(V);
  for (int v = 0; v &lt; V; v++)
  {
      // Recur for all the vertices adjacent to this vertex
      list&lt;int&gt;::iterator i;
      for (i = adj[v].begin(); i != adj[v].end(); ++i)
      {
          g.adj[*i].push_back(v);
          (g.in[v])++;
      }
  }
  return g;
  }
  
  // This function returns true if all non-zero degree vertices of 
  // graph are strongly connected
  bool Graph::isSC()
  {
  // Mark all the vertices as not visited (For first DFS)
  bool visited[V]; // error: 'this' cannot be used in a constant expression
  for (int i = 0; i &lt; V; i++)
      visited[i] = false;
  
  // Find the first vertex with non-zero degree
  int n;
  for (n = 0; n &lt; V; n++)
      if (adj[n].size() &gt; 0)
          break;
  
  // Do DFS traversal starting from first non zero degree vertex.
  DFSUtil(n, visited);
  
  // If DFS traversal doesn't visit all vertices, then return false.
  for (int i = 0; i &lt; V; i++)
      if (adj[i].size() &gt; 0 &amp;&amp; visited[i] == false)
          return false;
  
  // Create a reversed graph
  Graph gr = getTranspose();
  
  // Mark all the vertices as not visited (For second DFS)
  for (int i = 0; i &lt; V; i++)
      visited[i] = false;
  
  // Do DFS for reversed graph starting from first vertex.
  // Staring Vertex must be same starting point of first DFS
  gr.DFSUtil(n, visited);
  
  // If all vertices are not visited in second DFS, then
  // return false
  for (int i = 0; i &lt; V; i++)
      if (adj[i].size() &gt; 0 &amp;&amp; visited[i] == false)
          return false;
  
  return true;
  }
  </code></pre>