The problem with IntelliSense in VS2022 (C++) - c++

Question

I have a problem with IntelliSense in VS 2022. For some reason, for the data structures implemented by me, it does not always work (that is, it works in some methods, in some it does not). The message "IntelliSense no members available (see 'configure aC++ project for IntelliSense' for further help)" is displayed. The indicated article did not help. My code is below.
For example, in the Graph::Vertex(const Vertex& other) constructor, it works for the other parameter (line 117). But for the minVertex variable in the vector<Edge> prim(const T& startData)* method (line 327) - no. I didn't find anything on my problem in Google, so I will be glad of any help :)
#include <iostream>
#include <vector>
#include <cassert>
#include <algorithm>
#include <climits>
#include <iomanip>
#include <string>
#include <map>
using namespace std;
const int INF = INT_MAX;
template<typename T>
class Graph {
public:
struct Edge;
struct Vertex;
private:
vector<Vertex> vertices;
vector<Edge*> pAllEdges;
size_t numberOfVisited;
public:
string(*dataToString) (const T& data);
struct Edge {
Vertex* pFirstVertex;
Vertex* pSecondVertex;
int weight;
Graph* pGraph;
Edge(Vertex* pFirstVertex, Vertex* pSecondVertex, int weight, Graph* pGraph)
: pFirstVertex(pFirstVertex)
, pSecondVertex(pSecondVertex)
, weight(weight)
, pGraph(pGraph) {
;
}
Edge()
: pFirstVertex(nullptr)
, pSecondVertex(nullptr)
, weight(0)
, pGraph(nullptr) {
;
}
Edge(const Edge& other) {
*this = other;
}
~Edge() { ; }
Edge& operator=(const Edge& other) {
pFirstVertex = other.pFirstVertex;
pSecondVertex = other.pSecondVertex;
weight = other.weight;
pGraph = other.pGraph;
return *this;
}
bool operator==(const Edge& other) const {
return this == &other;
}
Vertex& getOppositeVertex(const Vertex& vertex) const {
assert(vertex == *pFirstVertex || vertex == *pSecondVertex);
return *pFirstVertex == vertex ? *pSecondVertex : *pFirstVertex;
}
void swapEnds() {
Vertex* tmp = pFirstVertex;
pFirstVertex = pSecondVertex;
pSecondVertex = tmp;
}
friend ostream& operator<<(ostream& out, const typename Graph<T>::Edge& edge) {
out << "[" << edge.pFirstVertex << " " << edge.pGraph->dataToString(edge.pFirstVertex->data)
<< "]-" << edge.weight << "-["
<< edge.pSecondVertex << " " << edge.pGraph->dataToString(edge.pSecondVertex->data) << "]";
return out;
}
};
struct Vertex {
T data;
int weight;
Graph* pGraph;
bool isVisited;
vector<Edge*> pEdges;
size_t index;
Vertex(const T& data, int weight, Graph* pGraph)
: data(data)
, weight(weight)
, pGraph(pGraph)
, isVisited(false)
, index(INF) {
;
}
Vertex()
: weight(0)
, pGraph(nullptr)
, isVisited(false)
, index(INF)
, data(T()) {;}
Vertex(const Vertex& other) {
*this = other;
}
~Vertex() { ; }
Vertex & operator=(const Vertex & other) {
if (this != &other) {
data = other.data;
weight = other.weight;
pGraph = other.pGraph;
isVisited = other.isVisited;
index = other.index;
pEdges.clear();
}
return *this;
}
bool operator==(const Vertex& other) const {
return this == &other;
}
void visit() {
isVisited = true;
++pGraph->numberOfVisited;
}
friend ostream& operator<<(ostream& out, const Vertex& vertex) {
out << &vertex << " [" << (vertex.isVisited ? "X" : " ") << "] ";
out << "i: " << vertex.index << " w: " << vertex.weight << " d: ("
<< vertex.pGraph->dataToString(vertex.data) << ")";
return out;
}
};
struct VertexInfo {
T data;
int weight;
bool isVisited;
VertexInfo(const T& data, int weight, bool isVisited)
: data(data)
, weight(weight)
, isVisited(isVisited) {
;
}
};
Graph()
: numberOfVisited(0)
, dataToString(nullptr) {
;
}
Graph(string(*dataToString) (const T& data))
: numberOfVisited(0)
, dataToString(dataToString) {
;
}
Graph(const Graph& other) {
*this = other;
}
~Graph() {
for (Edge* pEdge : pAllEdges) {
delete pEdge;
}
}
Graph& operator=(const Graph& other) {
if (this != &other) {
for (Edge* pEdge : pAllEdges) {
delete pEdge;
}
pair<vector<VertexInfo>, vector<vector<int>>> info = other.getInfo();
vector<VertexInfo> vertexInfos = info.first;
vector<vector<T>> edgeInfos = info.second;
for (int i = 0; i < vertexInfos.size(); ++i) {
const VertexInfo& vertexInfo = vertexInfos[i];
vertices.push_back(Vertex(vertexInfo.data, vertexInfo.weight, this));
vertices.back().isVisited = vertexInfo.isVisited;
}
for (int i = 0; i < info.second.size(); ++i) {
for (int j = 0; j < info.second[0].size(); ++j) {
if (edgeInfos[i][j] != INF) {
Vertex& firstVertex = vertices[i];
Vertex& secondVertex = vertices[j];
addEdge(firstVertex, secondVertex, edgeInfos[i][j]);
}
}
}
dataToString = other.dataToString;
}
return *this;
}
Vertex* getVertexByData(const T& data) {
for (Vertex& vertex : vertices) {
if (vertex.data == data) {
return &vertex;
}
}
return nullptr;
}
bool edgeExists(const Vertex* pFirstVertex, const Vertex* pSecondVertex) {
return find_if(pAllEdges.begin(), pAllEdges.end(), [pFirstVertex, pSecondVertex](Edge* pEdge) {
return pEdge->pFirstVertex == pFirstVertex && pEdge->pSecondVertex == pSecondVertex
|| pEdge->pFirstVertex == pSecondVertex && pEdge->pSecondVertex == pFirstVertex;
}) != pAllEdges.end();
}
void addVertex(const T& data, int weight) {
vector<Vertex*> pVerticesOld;
for (Vertex& vertex : vertices) {
pVerticesOld.push_back(&vertex);
}
Vertex* pFirstVertexOld = nullptr;
if (vertices.size() > 0) {
pFirstVertexOld = &vertices[0];
}
vertices.push_back(Vertex(data, weight, this));
size_t vertexIndex = vertices.size() - 1;
vertices[vertexIndex].index = vertexIndex;
Vertex* pFirstVertexNew = &vertices[0];
if (pFirstVertexOld != nullptr && pFirstVertexNew != pFirstVertexOld) {
for (Edge* pEdge : pAllEdges) {
size_t index;
index = find_if(pVerticesOld.begin(), pVerticesOld.end(), [pEdge](Vertex* pVertex) {
return pVertex == pEdge->pFirstVertex;
}) - pVerticesOld.begin();
pEdge->pFirstVertex = &vertices[index];
pEdge->pFirstVertex->pEdges.push_back(pEdge);
index = find_if(pVerticesOld.begin(), pVerticesOld.end(), [pEdge](Vertex* pVertex) {
return pVertex == pEdge->pSecondVertex;
}) - pVerticesOld.begin();
pEdge->pSecondVertex = &vertices[index];
pEdge->pSecondVertex->pEdges.push_back(pEdge);
}
}
}
void addEdge(Vertex& firstVertex, Vertex& secondVertex, int weight) {
if (edgeExists(&firstVertex, &secondVertex)) {
return;
}
Edge* pNewEdge = new Edge(&firstVertex, &secondVertex, weight, this);
firstVertex.pEdges.push_back(pNewEdge);
secondVertex.pEdges.push_back(pNewEdge);
pAllEdges.push_back(pNewEdge);
}
void addEdge(const T& firstData, const T& secondData, int weight) {
Vertex* pFirstVertex = getVertexByData(firstData);
Vertex* pSecondVertex = getVertexByData(secondData);
addEdge(*pFirstVertex, *pSecondVertex, weight);
}
pair<vector<VertexInfo>, vector<vector<int>>> getInfo() const {
vector<VertexInfo> vertexInfos;
for (const Vertex& vertex : vertices) {
vertexInfos.push_back(VertexInfo(vertex.data, vertex.weight, vertex.isVisited));
}
vector<vector<int>> adjacencyMatrix(vertices.size(), vector<int>(vertices.size(), INF));
for (const Edge* pEdge : pAllEdges) {
size_t iFirstVertex = pEdge->pFirstVertex->index;
size_t iSecondVertex = pEdge->pSecondVertex->index;
adjacencyMatrix[iFirstVertex][iSecondVertex] = pEdge->weight;
}
return { vertexInfos, adjacencyMatrix };
}
size_t getNumberOfVertices() const {
return vertices.size();
}
size_t getNumberOfVisited() const {
return numberOfVisited;
}
size_t getNumberOfEdges() const {
return pAllEdges.size();
}
vector<Edge*> prim(const T& startData) {
Vertex* pStart = getVertexByData(startData);
pStart->weight = 0;
pStart->visit();
vector<Edge*> result;
while (getNumberOfVisited() != getNumberOfVertices()) {
Vertex* pNeighbor = nullptr;
Edge* pMinEdge = nullptr;
Vertex* pMinVertex = nullptr;
int minWeight = INF;
for (const Vertex& vertex : vertices) {
if (vertex.isVisited) {
for (Edge* pEdge : vertex.pEdges) {
pNeighbor = &pEdge->getOppositeVertex(vertex);
if (!pNeighbor->isVisited && pEdge->weight < minWeight) {
minWeight = pEdge->weight;
pMinEdge = pEdge;
pMinVertex = pNeighbor;
}
}
}
}
if (pMinEdge != nullptr) {
pMinVertex->visit();
result.push_back(pMinEdge);
}
}
return result;
}
const map<const Vertex*, const Vertex*> dijkstra(const T& start) {
map<const Vertex*, const Vertex*> result;
Vertex * pStart = getVertexByData(start);
pStart->visit();
pStart->weight = 0;
while (getNumberOfVisited() != getNumberOfVertices()) {
Vertex* pMinVertex = nullptr;
for (Vertex& vertex : vertices) {
if (!vertex.isVisited) {
if (pMinVertex == nullptr || vertex.weight < pMinVertex->weight) {
pMinVertex = &vertex;
}
}
}
for (const Edge* pEdge : pMinVertex->pEdges) {
Vertex& neighbor = pEdge->getOppositeVertex(*pMinVertex);
if (!neighbor.isVisited) {
int tentativeValue = pMinVertex->weight + pEdge->weight;
if (tentativeValue < neighbor.weight) {
neighbor.weight = tentativeValue;
result[&neighbor] = pMinVertex;
}
}
}
pMinVertex->visit();
}
return result;
}
static void printInfo(const pair<vector<VertexInfo>, vector<vector<int>>>& info) {
for (const VertexInfo& vd : info.first) {
cout << to_string(vd.data) << " " << vd.weight << " " << boolalpha << vd.isVisited << endl;
}
for (auto& row : info.second) {
for (auto& elem : row) {
cout << setw(11) << elem;
}
cout << endl;
}
}
friend ostream& operator<<(ostream& out, const Graph& graph) {
for (const Vertex& vertex : graph.vertices) {
out << vertex << endl;
for (const Edge* pEdge : vertex.pEdges) {
cout << "\t" << *pEdge << endl;
}
}
return out;
}
};
string dataToString(const int& data) {
return to_string(data);
}
string dataToString(const pair<int, int>& data) {
return "(" + to_string(data.first) + ", " + to_string(data.second) + ")";
}
int main() {
Graph<int> g(dataToString);
g.addVertex(1, INF);
g.addVertex(2, INF);
g.addVertex(3, INF);
g.addVertex(4, INF);
g.addVertex(5, INF);
g.addVertex(6, INF);
g.addEdge(1, 2, 4);
g.addEdge(1, 3, 4);
g.addEdge(2, 3, 2);
g.addEdge(3, 4, 3);
g.addEdge(3, 5, 2);
g.addEdge(3, 6, 4);
g.addEdge(4, 6, 3);
g.addEdge(5, 6, 3);
//Graph<int>::printInfo(g.getInfo());
cout << g << endl << endl << endl;
Graph g1(g);
Graph<int> g2;
g2 = g;
//vector<Graph<int>::Edge*> pedges = g2.prim(3);
map<const Graph<int>::Vertex*, const Graph<int>::Vertex*> previousVertices = g2.dijkstra(3);
cout << g2 << endl;
return 0;
}