Compilando programas em C++

Neste capítulo, vamos aprender a compilar e executar programas com um único arquivo e projetos na linguagem C++.

No terminal, abra a pasta c_cpp_projects que criamos anteriormente para guardar nossos projetos.

1
cd ~/dev/c_cpp_projects

Programa

Crie um diretório chamado binary_tree, entre nele e abra-o no Visual Studio Code.

1
mkdir -p binary_tree
2
cd binary_tree
3
code .

Lembre-se de ativar o perfil C/C++ que criamos no capítulo Configurando o VSCode.

Crie um arquivo chamado main.cpp e adicione o seguinte código.

1
#include <iostream>
2

3
using namespace std;
4

5
int main()
6
{
7
    cout << "Hello, World!" << endl;
8
    return 0;
9
}

A estrutura do projeto ficará como a seguir.

Directorybinary_tree
- main.cpp

Para compilar o código, utilizamos o comando clang++, em vez de apenas clang. A estrutura do comando é a mesma. Antes de executá-lo, vamos criar uma pasta chamada build para guardar o arquivo binário gerado.

1
mkdir -p build
2
clang++ main.cpp -o build/binary_tree

Para executar o programa, basta chamar o arquivo binário gerado.

1
./build/binary_tree

Terminal com os comandos para compilar e executar o programa "Binary Tree", cujo resultado é "Hello, World!" — Compilação e execução do programa "Binary Tree".

Projeto

Vamos editar este projeto para de fato representar uma árvore binária. Crie duas pastas dentro do projeto: tree e node.

1
mkdir -p tree node

Dentro de tree, crie um arquivo tree.cpp e um tree.hpp.
Dentro de node, crie um arquivo node.cpp e um node.hpp.

1
touch tree/tree.cpp tree/tree.hpp node/node.cpp node/node.hpp

Na raiz do projeto, crie os arquivos main.cpp, .clang-format e .clang-tidy.

1
touch main.cpp .clang-format .clang-tidy

Use os snippets para preencher o conteúdo dos arquivos de formatação e de linting.

A estrutura do projeto deve ficar da seguinte forma.

Directorybuild
- …
Directorynode
- node.cpp
- node.hpp
Directorytree
- tree.cpp
- tree.hpp
.clang-format
.clang-tidy
main.cpp

Copie o conteúdo de todos os trechos de código abaixo para os respectivos arquivos criados. Não se esqueça de salvar cada um deles.

1
#include "tree/tree.hpp"
2
#include <iostream>
3

4
using namespace std;
5

6
int main() {
7
  Tree tree;
8

9
  tree.insert(5);
10
  tree.insert(3);
11
  tree.insert(8);
12
  tree.insert(1);
13
  tree.insert(4);
14
  tree.insert(7);
15
  tree.insert(9);
16

17
  tree.print();
18

19
  cout << endl;
20

21
  return 0;
22
}

1
#ifndef __NODE_HPP__
2
#define __NODE_HPP__
3

4
class Node {
5
private:
6
  int data;
7
  Node *left;
8
  Node *right;
9

10
public:
11
  Node(int data);
12
  ~Node() {}
13

14
  int getData();
15
  Node *getLeft();
16
  Node *getRight();
17

18
  void setData(int data);
19
  void setLeft(Node *left);
20
  void setRight(Node *right);
21
};
22

23
#endif // __NODE_HPP__

1
#include "node.hpp"
2

3
Node::Node(int data) {
4
    this->data = data;
5
    left = nullptr;
6
    right = nullptr;
7
}
8

9
int Node::getData() {
10
    return data;
11
}
12

13
Node *Node::getLeft() {
14
    return left;
15
}
16

17
Node *Node::getRight() {
18
    return right;
19
}
20

21
void Node::setData(int data) {
22
    this->data = data;
23
}
24

25
void Node::setLeft(Node *left) {
26
    this->left = left;
27
}
28

29
void Node::setRight(Node *right) {
30
    this->right = right;
31
}

1
#ifndef __TREE_HPP__
2
#define __TREE_HPP__
3

4
#include "../node/node.hpp"
5

6
class Tree {
7
    private:
8
        Node *root;
9

10
        void insert(Node *node, int data);
11
        void print(Node *node);
12

13
    public:
14
        Tree();
15
        ~Tree();
16

17
        void insert(int data);
18
        void print();
19
};
20

21
#endif  // __TREE_HPP__

1
#include "tree.hpp"
2

3
#include <iostream>
4

5
using namespace std;
6

7
Tree::Tree() {
8
    root = nullptr;
9
}
10

11
Tree::~Tree() {
12
    Node *current = root;
13
    while (current != nullptr) {
14
        Node *temp = current;
15
        current = current->getRight();
16
        delete temp;
17
    }
18
}
19

20
void Tree::insert(int data) {
21
    if (root == nullptr) {
22
        root = new Node(data);
23
    } else {
24
        insert(root, data);
25
    }
26
}
27

28
void Tree::insert(Node *node, int data) {
29
    if (data < node->getData()) {
30
        if (node->getLeft() == nullptr) {
31
            node->setLeft(new Node(data));
32
        } else {
33
            insert(node->getLeft(), data);
34
        }
35
    } else {
36
        if (node->getRight() == nullptr) {
37
            node->setRight(new Node(data));
38
        } else {
39
            insert(node->getRight(), data);
40
        }
41
    }
42
}
43

44
void Tree::print() {
45
    print(root);
46
}
47

48
void Tree::print(Node *node) {
49
    if (node != nullptr) {
50
        print(node->getLeft());
51
        cout << node->getData() << " ";
52
        print(node->getRight());
53
    }
54
}

Antes de compilar o projeto, vamos inicializar o controle de versão com o Git.

Crie o arquivo .gitignore na raiz do projeto, e o preencha com o snippet gitignore-c-cpp.

A estrutura do projeto deve ficar da seguinte forma.

Directorybuild
- …
Directorynode
- node.cpp
- node.hpp
Directorytree
- tree.cpp
- tree.hpp
.clang-format
.clang-tidy
.gitignore
main.cpp

Então, inicialize o repositório Git e faça o primeiro commit.

1
git init
2
git add .
3
git commit -m "Initialize project"

Compilação

Para compilar o projeto, precisamos passar todos os arquivos para o compilador. Fazemos isso usando o comando clang++ da seguinte maneira:

1
clang++ <arquivos.cpp> -I <pastas_com_arquivos.hpp> -o <executável>

<arquivos.cpp>: todos os arquivos .cpp do projeto.
<pastas_com_arquivos.hpp>: todas as pastas que contêm arquivos .hpp do projeto.
<executável>: nome do arquivo binário gerado.

Ou seja, precisamos especificar a localização de todos os arquivos que desejamos incluir e compilar. Dado que nosso projeto tem mais de uma pasta internamente, precisamos especificar a localização de todas elas. Execute o código a seguir.

1
mkdir -p build
2
clang++ tree/tree.cpp node/node.cpp main.cpp -I tree -I node -o build/binary_tree

Para executar o programa, basta chamar o arquivo binário gerado.

1
./build/binary_tree

Se tudo estiver correto, você verá os nós da árvore binária sendo impressos no terminal em ordem crescente.

Terminal com os comandos para compilar e executar o projeto "binary_tree", cujo resultado é "1 3 4 5 7 8 9" — Compilação e execução do projeto "binary_tree".

Configurações

Assim como fizemos para projetos em C, podemos configurar tarefas de compilação para C++ no Visual Studio Code. Se você seguiu os passos recomendados no capítulo Configurando o VSCode, já está configurada uma tarefa de compilação para C++.

Infelizmente, essa tarefa apenas compila os arquivos .cpp que estiverem na raiz do projeto. Uma vez que nosso projeto tem arquivos em pastas diferentes, precisamos especificar a localização de todos eles.

Dessa forma, a tarefa de compilação global não é suficiente para compilar o projeto binary_tree. Precisamos criar um arquivo de tarefa personalizado para isso.

Nós configuramos alguns snippets para facilitar a construção do arquivo tasks.json. Crie uma pasta chamada .vscode na raiz do projeto e um arquivo chamado tasks.json dentro dela.

1
mkdir -p .vscode
2
touch .vscode/tasks.json

A estrutura do projeto deve ficar da seguinte forma.

Directory.vscode
- tasks.json
Directorybuild
- …
Directorynode
- node.cpp
- node.hpp
Directorytree
- tree.cpp
- tree.hpp
.clang-format
.clang-tidy
main.cpp

Garanta que o perfil C/C++ esteja ativo e abra o arquivo tasks.json. Digite nele tasks-json e pressione Enter Enter para preencher o arquivo com o snippet.

Visual Studio Code com o arquivo "tasks.json" aberto, sugerindo o preenchimento com o snippet para construção de tarefas. — Construção do arquivo "tasks.json".

Então, dentro do vetor tasks, digite cpp-build-task e pressione Enter Enter para preencher o arquivo com o snippet.

Visual Studio Code com o arquivo "tasks.json" aberto, sugerindo o preenchimento com o snippet para a tarefa de compilação de C++. — Preenchimento da tarefa de compilação "cpp-build-task".

Agora, observe o campo args do arquivo tasks.json. Ele contém os argumentos que passamos para o comando de compilação. Atualmente, ele recebe todos os arquivos .cpp que estejam na raiz do projeto.

1
"args": [
2
  "-fcolor-diagnostics",
3
  "-fansi-escape-codes",
4
  "-g",
5
  "${workspaceFolder}/*.cpp",
6
  "-I",
7
  "${workspaceFolder}",
8
  "-o",
9
  "${workspaceFolder}/build/${workspaceFolderBasename}"
10
],

Precisamos passar, além desses, todos os arquivos .cpp que estão nas pastas tree e node. Para isso, adicionamos uma linha para cada pasta. O atalho ${workspaceFolder} representa a pasta raiz do projeto. Por isso, cada linha se inicia com ele.

O arquivo tasks.json deve ficar como abaixo.

1
{
2
  "version": "2.0.0",
3
  "tasks": [
4
    {
5
      "args": [
6
        "-fcolor-diagnostics",
7
        "-fansi-escape-codes",
8
        "-g",
9
        "${workspaceFolder}/*.cpp",
10
        "${workspaceFolder}/node/*.cpp",
11
        "${workspaceFolder}/tree/*.cpp",
12
        "-I",
13
        "${workspaceFolder}",
14
        "-o",
15
        "${workspaceFolder}/build/${workspaceFolderBasename}"
16
      ],
17
      "command": "clang++",
18
      "detail": "Tarefa de compilação de um projeto em C++. Compila todos os arquivos C++ ligados do projeto em um único executável.",
19
      "group": {
20
        "kind": "build"
21
      },
22
      "label": "Clang: build C++ project (Local)",
23
      "options": {
24
        "cwd": "${workspaceFolder}"
25
      },
26
      "problemMatcher": ["$gcc"],
27
      "type": "cppbuild"
28
    }
29
  ]
30
}

Poderemos então usar o atalho Control + Shift + B Control + Shift + B para abrir o painel de tarefas de compilação. Então selecione a Clang: build C++ project (Local).

Visual Studio Code com o painel de tarefas aberto, mostrando a tarefa "Clang: build C++ project (Local)" selecionada. — Compilação do projeto "binary_tree" com a tarefa personalizada.

O Visual Studio Code compilará o projeto e mostrará o resultado no terminal integrado.

Terminal integrado do Visual Studio Code com a saída da compilação do projeto "binary_tree". — Saída da compilação do projeto "binary_tree".