Перевести с python в C++

# Python 3.9.0
class Matrix:
 
    def __init__(self, array: list[list[int]] = None, message: str = None, size: int = None) -> None:
        self.matrix: list = []
        self.inputting(array, message, size)
 
    def inputting(self, array: list[list[int]] = None, message: str = None, size: int = None) -> None:
 
        if type(array) is list:
 
            for i in range(len(array)):
                if not(len(array[i]) == len(array)):
                    raise ValueError("Array must be square")
            self.matrix = array
 
            return
 
        elif type(size) is int and size > 0:
 
            if message is not None:
                print(message)
 
            print('  |', end='')
            for i in range(size):
                print('x' + str(i + 1), end='|')
            print()
 
            for i in range(size):
                print('x' + str(i + 1), end='|')
                row = list(
                    map(int, input().split('  '))
                )
                self.matrix.append(row)
 
            return
 
        if array is None and size is None:
            raise ValueError("Either 'array' or 'size' must be initialized")
        else:
            raise ValueError("'array' must be of type list, 'size' must be of type int")
 
    def outputting(self, names: list = None) -> None:
        if names is None:
            names = [f"x{x}" for x in range(len(self.matrix))]
 
        print(f'{" " * len(str(names[-1]))}|', end='')
        for name in names:
            print(name, end='|')
        print()
 
        for i in range(len(self.matrix)):
            print(f'{names[i]}{" " * (len(names[-1]) - len(names[i]))}', end='|')
            for j in range(len(self.matrix)):
                if self.matrix[i][j] != 0:
                    print(f'{self.matrix[i][j]}{" " * (len(str(names[j])) - len(str(self.matrix[i][j])))}', end='|')
                else:
                    print(" " * len(str(names[j])), end='|')
            print()
 
class Graph:
 
    def __init__(self, matrix: Matrix):
 
        if type(matrix) is not Matrix:
            raise ValueError("Graph must be initialized with an object of type 'Matrix'")
 
        self.adjacency_table: Matrix = matrix
        self.count: int = len(self.adjacency_table.matrix)
 
    def dijkstra(self, start: int, finish: int) -> tuple[int, list[int]]:
        path_table = self.adjacency_table.matrix
 
        path_length: list = [float('inf') for _ in range(self.count)]  # all point get 'inf'
        path_length[start] = 0  # start point get zero
 
        colored_points = [start]  # colored points will go here
        last_permanent = start
 
        while last_permanent != finish:
            # if path not exist
            if len(colored_points) == self.count:
                return -1, [-1]
 
            temp_path_length = path_length[:]
 
            # update length
            for w in range(self.count):
                if w in colored_points:
                    continue
                edge = path_length[last_permanent] + path_table[last_permanent][w] if path_table[last_permanent][w]\
                    else float('inf')
                path_length[w] = min(temp_path_length[w], edge)
 
            # search permanent point
            not_colored_points = []
            for point in range(self.count):
                if point in colored_points:
                    not_colored_points.append(float('inf'))
                else:
                    not_colored_points.append(path_length[point])
 
            def index_min(array):
                min_el = min(array)
                return array.index(min_el)
 
            last_permanent = index_min(not_colored_points)
            colored_points.append(last_permanent)
 
        shortest_path_length: int = path_length[last_permanent]
 
        def create_path(points, begin, end, adj_table):
            chain = [end]
            node = end
 
            while node != begin:
                for point in points:
                    if adj_table[point][node]:
                        node = point
                        chain.append(node)
                        break
 
            chain.reverse()
            return chain
 
        return shortest_path_length, create_path(colored_points, start, finish, path_table)
 
def print_path(weight: int, path: list) -> None:
    print(f'length path: {weight}')
 
    print('path: ', end='')
    for name in path:
        if name == path[-1]:
            break
        print(f'x{name}', end=' => ')
    print(f'x{path[-1]}')
 
def main():
 
    while True:
 
        point = input('(points amount)>>>').lower()
        if point == '-1':
            break
 
        if point == 'var9':
            print('matrix for option 9')
            table = Matrix(array=[
                [0,  0, 0,  25, 0,  7,  0, 0,  0, 0, 0,  0],
                [11, 0, 12, 0,  0,  0,  0, 0,  0, 0, 0,  0],
                [0,  8, 0,  9,  26, 11, 0, 13, 0, 0, 0,  0],
                [24, 0, 0,  0,  12, 0,  0, 0,  0, 0, 0,  0],
                [0,  0, 0,  0,  0,  0,  0, 0,  0, 0, 0,  9],
                [6,  0, 0,  0,  0,  0,  3, 0,  0, 0, 0,  0],
                [0,  0, 16, 0,  0,  0,  0, 0,  0, 0, 0,  0],
                [0,  0, 5,  0,  0,  16, 8, 0,  2, 3, 0,  0],
                [0,  0, 0,  0,  0,  0,  0, 0,  0, 5, 3,  0],
                [0,  0, 0,  8,  0,  0,  0, 0,  0, 0, 12, 10],
                [0,  0, 0,  0,  0,  0,  0, 0,  4, 0, 0,  6],
                [0,  0, 0,  13, 11, 0,  0, 0,  0, 0, 0,  0]
            ])
            table.outputting()
        elif point == 'lec7':
            print('example from presentation to lecture 7')
            table = Matrix(array=[
                [0, 3, 0, 0, 0, 2],
                [0, 0, 0, 2, 0, 0],
                [4, 7, 0, 0, 3, 0],
                [0, 0, 0, 0, 0, 0],
                [0, 0, 0, 0, 0, 3],
                [0, 0, 0, 2, 0, 0]
            ])
            table.outputting()
        else:
            point = int(point)
            table = Matrix(message='\n(input adjacency table)>>>', size=point)
 
        variant = Graph(table)
 
        begin, end = map(int, input('(enter start & end points)>>>').split())
        print_path(*variant.dijkstra(begin, end))
 
if __name__ == "__main__":
    main()