CS50: S2 | Aula
Tags: braziliandevs
Published: 2022-05-03 13:47:23

## Recapitulando

Semana passada acompanhamos a [semana 1](https://dev.to/mpfdev/cs50-semana-1-1ib3) do aclamado curso CS50, da universidade de Harvard, onde fomos apresentados os blocos fundamentais das linguagens de programação.

- Tipos de Dados
- Intruções

Nos tipos de dados, vimos sobre a importância de determinar para o programa que com tipo de dado iremos trabalhar, se será um número inteiro (**int**), um número real (**float**), se nosso dado é um booleano (**bool**), e outros tipos de dados. Dentro dos tipos de dados, também nos foi apresentado sobre as variáveis e como a usamos para armazenar dados (informações).

Assim como também vimos que os programas são sequências de instruções, onde podemos trabalhar de forma repetitiva e usando expressões para controlar o fluxo de uma operação.

Para relembrar algumas coisas, aqui está o post que eu fiz sobre a [semana 1](https://dev.to/mpfdev/cs50-semana-1-1ib3), onde elaborei algumas perguntas sobre a primeira aula.

## Introdução

Até agora, estamos utilizando o universo na nuvem que o curso preparou para os alunos para que todos estejam utilizando as mesmas condições para desenvolver seus programas. E com isso, percebe-se, assim como na biblioteca especial `cs50` que estamos utilizando, temos acesso a comandos que não existem em outros ambientes de desenvolvimento, como por exemplo, o que estamos utilizando para compilar nosso programa desenvolvido em C.

### Compilando Programas

Assim, para rodarmos todos os programas que desenvolvemos até agora, precisamos:

1) Abrir o Terminal na nuvem do cs50.
2) Escrever: `make programa.c`
3) Escrever: `./programa`
4) Assim nosso programa será executado

Acontece que esse `make nomeDoPrograma.c` não é nativo do ambiente de programação em C.

Desta maneira somos introduzidos ao comando  `clang` para trabalhar como compilador da linguagem de forma manual.

### Debugging

O professor [David J. Malan](https://cs.harvard.edu/malan/) introduz o conceito de `debugging` que é quando existe um bug/erro/problema em nosso código, e usamos alguma ferramenta para procurar os erros.
Essas ferramentas podem ser desde o uso do `printf` para exibir em tela como os comandos estão sendo executados, até usar como o `debug50` ferramenta desenvolvida pelo CS50 para usar dentro do ambiente de programação em nuvel do curso.

![debug50](https://i.imgur.com/vX9hFdi.png)

Onde o professor ensina a interpretar, conhecer e usar a ferramenta para `debugar` o seu código.

### Memória

Uma importante parte da aula onde o professor [David J. Malan](https://cs.harvard.edu/malan/) de maneira exemplar traduz o que seria esse espaço na memória toda vez que precisamos usar ou armazenar um **tipo de dado**. Ele exemplifica utilizando um grid para representar a memória como conhecemos.

![memory](https://cs50.harvard.edu/x/2022/notes/2/ram.png)

E utilizando os exemplos em aula das variaveis que ele está usando no momento como, em teoria, estariam armazenadas.

![memory_variable](https://cs50.harvard.edu/x/2021/notes/2/scores.png)

![memory_binary](https://cs50.harvard.edu/x/2022/notes/2/binary.png)

*Essas imagens foram retiradas da própria página do cs50*

### Arrays

Aqui é apresentado as Arrays. Um outro **tipo de dado** que funciona como uma lista que pode armazenar múltiplos valores que sejam do **mesmo tipo**. 
Então uma array de números, será uma lista composta por um determinado números de itens, onde estes itens são números.

```c
#include <cs50.h>
#include <stdio.h>

int main(void)
{
    int scores[3];

    for (int i = 0; i < 3; i++)
    {
      scores[i] = get_int("Score: ");
    }

    printf("Average: %f\n", (scores[0] + scores[1] + scores[2]) / 3.0);
}


```

Onde `int scores[3]` é definido que esta será uma lista com um tipo de dado **int**.
Por conta disso, dentro do loop `scores[i]` não é necessário definir como `int scores[i]` pois já é informado que este será uma lista de itens **int**.

### Characteres e Strings

O conhecimento é **acumulativo**!

Em seguida a parte da aula onde é tratado sobre o conceito e prática de Arrays, a aula entra para falar sobre outros tipos de dados como **char** e **strings**. E aqui, tudo se converge.

O professor [David J. Malan](https://cs.harvard.edu/malan/) apresenta duas formas que produzem o mesmo resultado para imprimir a mensagem em tela: `Hi!`

```c
#include <stdio.h>
  
int main(void)
{
    char c1 = 'H';
    char c2 = 'I';
    char c3 = '!';
  
    printf("%c%c%c\n", c1, c2, c3);
}
```

```c
#include <cs50.h>
#include <stdio.h>
  
int main(void)
{
    string s = "HI!";
    printf("%s\n", s);
}
```

Ambas produzirão a mesma mensagem em tela,

- Na primeira, vemos cada caracter sendo armazenado em váriaveis do tipo **char**.
- Na segunda, com a inclusão do header `cs50.h` vemos a utlização da variável do tipo **string**.

Percebe alguma semelhança entre a `string` e a `array`, como uma lista de caracteres? Interessante, não?

Dessa forma, conseguimos acessar os elementos da lista **s** (uma string) utilizando as `bracket notations` como vemos nesse exemplo, a seguir, dado em aula.

```c
#include <cs50.h>
#include <stdio.h>

int main(void)
{
    string s = "HI!";
    printf("%i %i %i\n", s[0], s[1], s[2]);
}

```

### Interface de Linha de Comando (CLI)

Na [primeira semana](https://dev.to/mpfdev/cs50-semana-1-1ib3) eu disse que nesse primeiro momento não precisariamos nos preocupar com `int main(void)`. Pois até então, nossa função principal ao ser chamada não recebia nenhum argumento. Nesta parte da aula é introduzido,

```c
#include <stdio.h>

int main(int argc, string argv[]) {
  //todo
}
```

Desta maneira, podemos criar programas agora que recebam argumentos, como por exemplo na função abaixo,

```c
#include <cs50.h>
#include <stdio.h>

int main(int argc, string argv[])
{
    printf("hello, %s\n", argv[1]);
}
```

```bash
./hello leitor
$ hello, leitor
```

Aqui, é muito importante lembrar que que esse argumento tem de ser um **char** ou uma **string**. Devido ao `argv` corresponder a uma `lista de caraceteres` apontando para todos os argumentos.


## Conclusão

Esse post não tem intenção de substituir a aula (até porque eu **não** falo sobre absolutamente tudo que é dado em aula) e é altamente recomendado que assista essa aula. A aula é bem completa e muito bem explicada em todos os seus conceitos e usos.

Essa aula passou sobre como podemos consertar nosso código (e que ter bug é normal, não se torture!). E aprofundou em memórias, sobre como os tipos de dados ocupam esses espaços, e como cabe a nós, desenvolvedores a saber que existe algo acontecendo por debaixo dos panos.

Ao terminar de assistir essa aula, deixei abaixo algumas perguntas que você será capaz de responder!

Ao longo dessa semana, postarei os **Problem Sets** relacionados a semana 2.

Obrigado por ler até aqui, vejo vocês logo!

## Verificando conhecimento

- Como os computadores entendem o código que estamos escrevendo?
- Como podemos compilar nossos programas manualmente em C?
- O que significa o pré-processador em C?
- Em qual etapa, o código é transformado em assembly?
- Após o código ser convertido em assembly, como ele é convertido em binário? (E afinal, porque converter código em binário é importante?)
- Debug é uma ferramente para fazer o que? E porque é importante?
- Como são chamados esses []? E pra que servem?
- Quando temos valores em char e imprimos usando %i, o que veremos na tela?
- O que é type casting?
- Em uma string, qual a função do NUL?
- Onde podemos encontrar informações sobre o header string.h?
- Dentro de um loop, o strlen() assume algum papel? Se sim, qual seria?
- Podemos estabelecer relações entre os chars de uma string usando ASCII?
- Se em vez de colocar uma palavra, colocar um número, com uma função main usando (int argc, string argv[]). Como esse número será tratado em C?
- O que podemos fazer usando o CLI?
- O que é o return 0 ao final de uma função?