模板c++

以下是一个简单的 C++ 模板：

#include <iostream>

template <typename T>
T add(T a, T b) {
    return a + b;
}

int main() {
    std::cout << add(1, 2) << std::endl; // 输出 3
    std::cout << add(3.5, 2.2) << std::endl; // 输出 5.7
    return 0;
}

这个示例程序定义了一个模板函数 `add`，用于计算任意类型的两个值的和。在 `main` 函数中，我们分别调用了 `add` 函数来计算两个整数和两个浮点数的和，并将结果输出到控制台。

相关问题

dfs代码模板c++

当然可以！以下是一个常见的深度优先搜索（DFS）的代码模板（C++）：

#include <iostream>
#include <vector>

using namespace std;

// 定义图的数据结构
class Graph {
private:
    int V; // 顶点的数量
    vector<vector<int>> adj; // 邻接表

public:
    Graph(int v) {
        V = v;
        adj.resize(V);
    }

    // 添加边
    void addEdge(int u, int v) {
        adj[u].push_back(v);
        adj[v].push_back(u);
    }

    // DFS遍历
    void DFS(int v, vector<bool>& visited) {
        visited[v] = true;
        cout << v << " ";

        // 递归访问所有未被访问过的邻接顶点
        for (int i = 0; i < adj[v].size(); i++) {
            int u = adj[v][i];
            if (!visited[u]) {
                DFS(u, visited);
            }
        }
    }

    // 对图进行DFS遍历
    void DFSTraversal() {
        vector<bool> visited(V, false); // 记录顶点是否被访问过

        // 从每个未被访问过的顶点开始进行DFS遍历
        for (int v = 0; v < V; v++) {
            if (!visited[v]) {
                DFS(v, visited);
            }
        }
    }
};

int main() {
    int V = 5; // 图的顶点数量
    Graph g(V);

    // 添加边
    g.addEdge(0, 1);
    g.addEdge(0, 2);
    g.addEdge(1, 3);
    g.addEdge(1, 4);

    cout << "DFS Traversal: ";
    g.DFSTraversal();

    return 0;
}

这个代码模板实现了一个简单的无向图的DFS遍历。你可以根据自己的需求进行修改和扩展。

bfs代码模板c++

当然可以！下面是一个基本的BFS（广度优先搜索）代码模板的C++实现：

#include <iostream>
#include <queue>
#include <vector>

using namespace std;

void bfs(vector<vector<int>>& graph, int start) {
    int n = graph.size();
    vector<bool> visited(n, false);  // 记录节点是否被访问过
    queue<int> q;  // 用于存储待访问的节点

    visited[start] = true;
    q.push(start);

    while (!q.empty()) {
        int node = q.front();
        q.pop();

        // 处理当前节点
        cout << node << " ";

        // 遍历当前节点的邻居节点
        for (int neighbor : graph[node]) {
            if (!visited[neighbor]) {
                visited[neighbor] = true;
                q.push(neighbor);
            }
        }
    }
}

int main() {
    // 构建图的邻接表表示
    vector<vector<int>> graph = {
        {1, 2},     // 节点0的邻居节点为1和2
        {0, 3, 4},  // 节点1的邻居节点为0、3和4
        {0, 5},     // 节点2的邻居节点为0和5
        {1},        // 节点3的邻居节点为1
        {1},        // 节点4的邻居节点为1
        {2}         // 节点5的邻居节点为2
    };

    int startNode = 0;  // 从节点0开始进行BFS

    bfs(graph, startNode);

    return 0;
}

这个代码模板使用了邻接表来表示图，通过队列来实现BFS。首先，我们创建一个`visited`数组来记录节点是否被访问过，初始时所有节点都未被访问。然后，我们创建一个队列`q`，将起始节点加入队列，并将其标记为已访问。接下来，我们进入循环，直到队列为空。在每次循环中，我们取出队列的头部节点，并处理该节点。然后，我们遍历该节点的邻居节点，如果邻居节点未被访问过，则将其加入队列并标记为已访问。最终，当队列为空时，BFS结束。