Variáveis. Tipos de dados.

Variáveis. Tipos de dados.
A utilidade dos programas "Hello World" mostrados na seção anterior é bastante questionável. Nós tivemos que escrever várias linhas de código, compilá-los e, em seguida, executar o programa resultante apenas para obter uma simples frase escrita na tela como resultado. Ele certamente teria sido muito mais rápido do que digitar a frase saída por nós mesmos. No entanto, a programação não se limita apenas à impressão de textos simples na tela. A fim de ir um pouco mais adiante e tornar-se capaz de escrever programas que executam tarefas úteis que realmente salvar-nos trabalhar, precisamos introduzir o conceito de variável.

Vamos pensar que eu lhe pedir para manter o número 5 em sua memória mental, e então eu lhe pedir para memorizar também o número dois ao mesmo tempo. Você tem apenas dois valores diferentes armazenados em sua memória. Agora, se eu pedir para você adicionar um para o primeiro número que eu disse, você deve manter os números 6 (que é 5 +1) e 2 em sua memória. Valores que poderiam agora, por exemplo, subtrair e obter 4 como resultado.

Todo o processo que você acabou de fazer com a sua memória mental é um símile do que um computador pode fazer com duas variáveis. O mesmo processo pode ser expresso em C + + com o seguinte conjunto de instruções:

1
2
3
4
a = 5;
b = 2;
a = a + 1;
result = a - b;

Obviamente, este é um exemplo muito simples, já que usamos somente dois pequenos valores inteiros, mas considere que o computador pode armazenar milhões de números como estes, ao mesmo tempo e realizar operações matemáticas sofisticadas com eles.

Portanto, podemos definir uma variável como uma parte da memória para armazenar um valor determinado.

Cada variável tem um identificador que o distingue dos outros. Por exemplo, no código anterior, os identificadores de variáveis ​​foram a, b e resultado, mas poderia ter chamado as variáveis ​​de todos os nomes que queríamos inventar, desde que eles eram identificadores válidos.

Identificadores
Um identificador válido é uma sequência de uma ou mais letras, números ou caracteres de sublinhado (_). Nem espaços nem sinais de pontuação ou símbolos podem ser parte de um identificador. Somente letras, números e caracteres de sublinhado simples são válidas. Além disso, os identificadores de variáveis ​​sempre tem que começar com uma letra. Eles também podem começar com um caractere sublinhado (_), mas em alguns casos, estas podem ser reservados por palavras-chave específicas do compilador ou identificadores externos, bem como identificadores contendo dois personagens sucessivos sublinhado em qualquer lugar. Em nenhum caso, eles podem começar com um dígito.

Outra regra que você tem que considerar quando se inventar seus próprios identificadores é que eles não podem corresponder a qualquer palavra-chave da linguagem C + +, nem aqueles específicos de seu compilador, que são palavras-chave reservadas. As palavras-chave reservadas padrão são:

asm, auto, bool, break, case, catch, char, class, const, const_cast, continue, default, delete, do, double, dynamic_cast, else, enum, explicit, export, extern, false, float, for, friend, goto, if, inline, int, long, mutable, namespace, new, operator, private, protected, public, register, reinterpret_cast, return, short, signed, sizeof, static, static_cast, struct, switch, template, this, throw, true, try, typedef, typeid, typename, union, unsigned, using, virtual, void, volatile, wchar_t, while 

Além disso, as representações alternativas para alguns operadores não pode ser utilizado como identificadores, uma vez que são palavras reservadas em algumas circunstâncias:

and, and_eq, bitand, bitor, compl, not, not_eq, or, or_eq, xor, xor_eq 

O compilador pode também incluir algumas palavras-chave reservadas específicas adicionais.

Muito importante: A linguagem C + + é uma linguagem "case sensitive". Isso significa que um identificador escrito em letras maiúsculas não é equivalente a um outro com o mesmo nome mas escrito em letras pequenas. Assim, por exemplo, a variável de resultado não é o mesmo que a variável de resultado ou a variável de resultado. Estes são três identificadores de variáveis ​​diferentes.

Tipos de dados fundamentais
Durante a programação, nós armazenamos as variáveis ​​na memória do nosso computador, mas o computador tem que saber que tipo de dados que deseja armazenar em si, uma vez que não vai ocupar a mesma quantidade de memória para armazenar um número simples de armazenar uma única letra ou um número grande, e eles não vão ser interpretadas da mesma maneira.

A memória em nossos computadores está organizado em bytes. Um byte é a quantidade mínima de memória que podemos gerenciar em C + +. Um byte pode armazenar uma quantidade relativamente pequena de dados: um único caractere ou um pequeno número inteiro (geralmente um número inteiro entre 0 e 255). Além disso, o computador pode manipular os tipos de dados mais complexos, que vêm do agrupamento de vários bytes, como números longos ou de números não inteiros.

Ainda tem um resumo dos tipos de dados fundamentais básicos em C + +, bem como a gama de valores que podem ser representados com cada um:

Name	Description	Size*	Range*
char	Character or small integer.	1byte	signed: -128 to 127 unsigned: 0 to 255
short int(short)	Short Integer.	2bytes	signed: -32768 to 32767 unsigned: 0 to 65535
int	Integer.	4bytes	signed: -2147483648 to 2147483647 unsigned: 0 to 4294967295
long int (long)	Long integer.	4bytes	signed: -2147483648 to 2147483647 unsigned: 0 to 4294967295
bool	Boolean value. It can take one of two values: true or false.	1byte	true or false
float	Floating point number.	4bytes	+/- 3.4e +/- 38 (~7 digits)
double	Double precision floating point number.	8bytes	+/- 1.7e +/- 308 (~15 digits)
long double	Long double precision floating point number.	8bytes	+/- 1.7e +/- 308 (~15 digits)
wchar_t	Wide character.	2 or 4 bytes	1 wide character

* Os valores da dimensão e colunas intervalo dependem do sistema, o programa é compilado. Os valores apresentados acima são os encontrados na maioria dos sistemas de 32 bits. Mas, para outros sistemas, a especificação geral é que int tem o tamanho natural, sugerida pela arquitectura do sistema (uma "palavra") e os quatro tipos inteiros char, curto e longo int devem cada um ser pelo menos tão grande como o que precede que, com carvão sendo sempre um byte de tamanho. O mesmo se aplica ao ponto flutuante tipo float, double double e longo prazo, onde cada um deve fornecer pelo menos tanta precisão quanto o anterior.

Declaração de variáveis
Para usar uma variável em C + +, devemos primeiro declará-lo especificando que tipo de dados que queremos que ele seja. A sintaxe para declarar uma nova variável é escrever o especificador do tipo de dados desejado (como int, bool, float ...) seguido por um identificador de variável válido. Por exemplo:

1
2
int a;
float mynumber;

Estas são duas declarações válidas de variáveis. O primeiro declara uma variável do tipo int com o identificador a. O segundo declara uma variável do tipo float com o varVezes identificador. Uma vez declarado, as variáveis ​​A e varVezes podem ser usados ​​dentro do resto do seu âmbito no programa.

Se você estiver indo para declarar mais de uma variável do mesmo tipo, você pode declarar todos eles em uma única instrução, separando seus identificadores com vírgulas. Por exemplo:

int a, b, c;

Esta declara três variáveis ​​(a, b e c), todos eles de tipo int, e tem exactamente o mesmo significado como:

1
2
3
int a;
int b;
int c;

Os tipos de dados inteiros char, short, long e int podem ser assinados ou não assinados de acordo com o intervalo de números necessários para ser representado. Tipos assinados podem representar valores positivos e negativos, ao passo que os tipos não assinados só pode representar valores positivos (e zero). Isto pode ser especificado usando o especificador assinado ou não assinado o especificador antes do nome do tipo. Por exemplo:

1 2	unsigned short int NumberOfSisters; signed int MyAccountBalance;

Por padrão, se não especificar a maioria das configurações do compilador assinado ou não assinado assumirá o tipo a ser assinado, portanto, em vez de a segunda declaração acima, poderia ter escrito:

int MyAccountBalance;

com exatamente o mesmo significado (com ou sem a palavra-chave assinado)

Uma exceção a esta regra geral é o tipo char, que existe por si só e é considerado um tipo diferente de dados fundamental de assinado char e unsigned char, pensado para armazenar caracteres. Você deve usar com ou sem sinal, se você pretende armazenar valores numéricos em uma variável do tipo char de tamanho.

curta e longa podem ser utilizados isoladamente como tipo especificadores. Neste caso, eles se referem a seus respectivos tipos fundamentais: inteiros short é equivalente a curto e longo int é equivalente a long int. As duas declarações de variáveis ​​a seguir são equivalentes:

1 2	short Year; short int Year;

Finalmente, assinada e sem sinal pode também ser utilizado como especificadores tipo independentes, ou seja, o mesmo que assinou int e unsigned int respectivamente. As duas declarações seguintes são equivalentes:

1
2
unsigned NextYear;
unsigned int NextYear;

Para ver o que as declarações de variáveis ​​parecer em ação dentro de um programa, vamos ver o código do exemplo sobre a sua memória mental, proposto no início desta seção C + +:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

// operating with variables #include <iostream> using namespace std; int main () { // declaring variables: int a, b; int result; // process: a = 5; b = 2; a = a + 1; result = a - b; // print out the result: cout << result; // terminate the program: return 0; }

4

Não se preocupe se algo mais do que as declarações de variáveis-se parece um pouco estranho para você. Você vai ver o resto em detalhes nas próximas seções.

Escopo de variáveis
Todas as variáveis ​​que pretendemos usar em um programa deve ter sido declarada com o seu especificador de tipo em um ponto anterior no código, como fizemos no código anterior, no início do corpo da função principal quando declarou que um, b, e resultado foram do tipo int.

Uma variável pode ser tanto de âmbito global ou local. Uma variável global é uma variável declarada no corpo principal do código de fonte, fora de todas as funções, enquanto que uma variável local é declarada dentro do corpo de uma função ou um bloco.



As variáveis ​​globais podem ser consultados em qualquer lugar do código, mesmo dentro de funções, sempre que após a sua declaração.

O escopo de variáveis ​​locais é limitado ao bloco entre chaves ({}), onde eles são declarados. Por exemplo, se forem declaradas no início do corpo de uma função (como na função principal), o seu âmbito é entre o seu ponto de declaração e no final dessa função. No exemplo acima, isto significa que, se existiu uma outra função além principal, as variáveis ​​locais declaradas no principal não pode ser acedida a partir da outra função e vice-versa.

Inicialização de variáveis
Ao declarar uma variável local regular, o seu valor é, por padrão indeterminado. Mas você pode querer uma variável para armazenar um valor concreto, no mesmo momento em que é declarada. A fim de fazer isso, você pode inicializar a variável. Há duas maneiras de fazer isso em C + +:

O primeiro, conhecido como c-como a inicialização, é feito adicionando um sinal de igual seguido do valor para o qual a variável será inicializada:

type identifier = initial_value ; 
Por exemplo, se quisermos declarar uma variável int chamada inicializado com um valor de 0, no momento em que for declarado, poderíamos escrever:

int a = 0;

A outra maneira de iniciar as variáveis, conhecidas como inicialização do construtor, é feito colocando o valor inicial entre parênteses (()):

Tipo de identificador (initial_value);
Por exemplo:

int a (0);

Ambas as formas de inicialização de variáveis ​​são válidos e equivalente em C + +.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

// initialization of variables #include <iostream> using namespace std; int main () { int a=5; // initial value = 5 int b(2); // initial value = 2 int result; // initial value undetermined a = a + 3; result = a - b; cout << result; return 0; }

6

Introdução às cordas
Variáveis ​​que podem armazenar valores não-numéricos, que são mais do que um único personagem são conhecidos como strings.

A + + biblioteca linguagem C fornece suporte para strings através da classe string padrão. Este é um tipo não fundamentais, mas comporta-se de uma maneira semelhante como tipos fundamentais fazer na sua utilização mais simples.

A primeira diferença com tipos de dados fundamentais é que, a fim de declarar e usar objetos (variáveis) desse tipo precisamos incluir um arquivo de cabeçalho adicional em nosso código fonte: <string> e ter acesso ao namespace std (que já tinha em todos os nossos programas anteriores graças à instrução using namespace).

1 2 3 4 5 6 7 8 9 10 11

// my first string #include <iostream> #include <string> using namespace std; int main () { string mystring = "This is a string"; cout << mystring; return 0; }

This is a string

Como você pode ver no exemplo anterior, as cordas podem ser inicializados com qualquer cadeia de caracteres válida literal como variáveis ​​do tipo numérico pode ser inicializado a qualquer numérico literal válido. Ambos os formatos de inicialização são válidos com strings:

1 2	string mystring = "This is a string"; string mystring ("This is a string");

Cordas também podem executar todas as outras operações básicas que tipos de dados fundamentais pode, gosta de ser declarada sem um valor inicial e sendo atribuídos valores durante a execução:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

// my first string #include <iostream> #include <string> using namespace std; int main () { string mystring; mystring = "This is the initial string content"; cout << mystring << endl; mystring = "This is a different string content"; cout << mystring << endl; return 0; }

This is the initial string content This is a different string content

Para mais detalhes sobre seqüências de C + +, você pode ter um olhar para a referência de classe string.

Estrutura de um programa

Estrutura de um programa

Provavelmente a melhor maneira de começar a aprender uma linguagem de programação é escrever um programa. Portanto, aqui está o nosso primeiro programa:

1 2 3 4 5 6 7 8 9 10

// meu primeiro programa em C++ #include <iostream> using namespace std; int main () { cout << "Olá Mundo!"; return 0; }

Olá Mundo!

O primeiro painel (em azul claro) mostra o código-fonte para o nosso primeiro programa. O segundo (em cinzento claro) mostra o resultado do programa, uma vez compilados e executado. À esquerda, os números em cinza representam os números de linha - não são parte do programa, e são mostrados aqui apenas para fins informativos.

A maneira de editar e compilar um programa depende do compilador que você está usando. Dependendo se ele tem uma interface de desenvolvimento ou não, e em sua versão. Consulte a seção de compiladores e do manual ou de ajuda incluído com o seu compilador, se você tem dúvidas sobre como compilar um programa C + + console.

O programa anterior é o típico programa que os aprendizes programador escrever, pela primeira vez, e seu resultado é a impressão na tela do "Olá mundo!" sentença. É um dos programas mais simples que podem ser escritos em C + +, mas que já contém os componentes fundamentais que cada programa de C + + tem. Vamos olhar linha por linha no código que acabou de escrever:

/ / Meu primeiro programa em C + +

Esta é uma linha de comentário. Todas as linhas que começam com dois sinais de barra (/ /) são consideradas comentários e não tem qualquer efeito sobre o comportamento do programa. O programador pode utilizá-los para incluir explicações curtas ou observações dentro do próprio código fonte. Neste caso, a linha é uma breve descrição do que é o nosso programa.

#include <iostream>
As linhas que começam com um sinal de cardinal (#) são diretivas para o pré-processador. Eles não são linhas de código com expressões regulares, mas indicações para pré-processador do compilador. Neste caso, a diretiva #include diz ao pré-processador para incluir o arquivo padrão iostream. Este arquivo específico (iostream) inclui as declarações da biblioteca de entrada e saída padrão básico em C + +, e está incluído porque a sua funcionalidade vai ser usado mais tarde no programa.
using namespace std;

Todos os elementos do padrão C + + biblioteca são declarados dentro do que é chamado de um namespace, o namespace com o nome std. Portanto, a fim de acessar a sua funcionalidade, declaramos com esta expressão que nós estaremos usando essas entidades. Esta linha é muito freqüente em C + + programas que usam a biblioteca padrão, e na verdade ele será incluído na maioria dos códigos fonte incluídos nestes tutoriais.

int main ()

Esta linha corresponde ao início da definição da função main. A função main é o ponto por onde todos os programas em C + + iniciar sua execução, independentemente da sua localização dentro do código fonte. Não importa se há outras funções com outros nomes definidos antes ou depois - as instruções contidas na definição desta função serão sempre os primeiros a ser executados em qualquer programa C + +. Por essa mesma razão, é essencial que todos os programas em C + + tem uma função main.

A palavra main é seguido no código por um par de parênteses (()). Isso é porque ele é uma declaração de função: Em C + +, o que diferencia uma declaração de função de outros tipos de expressões são esses parênteses que seguem o seu nome. Opcionalmente, estes parênteses podem juntar uma lista de parâmetros dentro deles.

Logo após estes parênteses, podemos encontrar o corpo da função principal entre chaves ({}). O que está contido dentro desses aparelhos é o que a função faz quando ele é executado.
cout << "Hello World!";
Esta linha é uma declaração C + +. A declaração é uma expressão simples ou composto que pode realmente produzir algum efeito. Na verdade, esta afirmação só executa a ação que gera um efeito visível em nosso primeiro programa.

cout é o nome do fluxo de saída padrão em C + +, e o significado de toda a declaração é para inserir uma sequência de caracteres (neste caso a sequência Mundial Olá de caracteres) para o fluxo de saída padrão (cout, que corresponde geralmente ao tela).

cout é declarado no arquivo padrão iostream dentro do namespace std, então é por isso que precisávamos para incluir esse arquivo específico e declarar que iríamos usar este namespace específico anteriormente em nosso código.


Observe que a instrução termina com um caractere ponto e vírgula (;). Este personagem é usado para marcar o fim da declaração e, na verdade ele deve ser incluído no final de todas as demonstrações de expressão em todos os programas em C + + (um dos erros de sintaxe mais comuns é o fato de esquecer de incluir algum ponto e vírgula depois de uma declaração).
return 0;
A comando return faz com que a função main termine. return pode ser seguido por um código de retorno (no nosso exemplo é seguido pelo código de return com um valor de zero). Um código de 0 para a função main de retorno é geralmente interpretado como o programa funcionou como o esperado, sem quaisquer erros durante a sua execução. Esta é a forma mais usual de terminar um programa de console + + C.


Você deve ter notado que nem todas as linhas deste programa executar ações quando o código é executado. Havia linhas contendo apenas comentários (aquelas iniciadas por / /). Havia linhas com diretrizes para a pré-processador do compilador (aquelas iniciadas por #). Em seguida, houve linhas que começaram a declaração de uma função (neste caso, a função principal) e, finalmente, as linhas com declarações (como a inserção cout), que foram todos incluídos dentro do bloco delimitado pelas chaves ({}) de a função principal.


O programa foi estruturado em linhas diferentes, a fim de ser mais legível, mas em C + +, não temos regras estritas para separar instruções em linhas diferentes. Por exemplo, em vez de

1 2 3 4 5

int main () { cout << " Olá Mundo!"; return 0; }

Poderíamos ter escrito:

int main () { cout << "Olá Mundo!"; return 0; }

Tudo em apenas uma linha e isso teria exatamente o mesmo significado que o código anterior.

Em C + +, a separação entre as declarações é especificado com um ponto e vírgula final (;) no final de cada um, de modo a separação em diferentes linhas de código não importa em tudo para esta finalidade. Podemos escrever muitas declarações por linha ou escrever uma única instrução que leva muitas linhas de código. A divisão do código em linhas diferentes serve apenas para torná-lo mais legível e esquemático para os seres humanos que podem lê-lo.

Vamos adicionar uma instrução adicional para nosso primeiro programa:

1 2 3 4 5 6 7 8 9 10 11 12

// Meu segundo programa em C++ #include <iostream> using namespace std; int main () { cout << "Olá Mundo! "; cout << "Eu sou um programa c++"; return 0; }

Olá Mundo! Eu sou um programa c++

Neste caso, foram realizadas duas inserções em cout em duas demonstrações diferentes. Mais uma vez, a separação em diferentes linhas de código tenha sido feito apenas para dar maior legibilidade ao programa, uma vez main pode ter sido perfeitamente válida definida da seguinte forma:

 
int main () { cout << " Hello World! "; cout << " I'm a C++ program "; return 0; }


Também estavam livres para dividir o código em mais linhas, se considerou mais conveniente:





1
2
3
4
5
6
7
8
int main ()
{
  cout <<
    "Olá Mundo!";
  cout
    << "Eu sou um programa c++";
  return 0;
}




E o resultado de novo teria sido exactamente o mesmo como nos exemplos anteriores.

Directivas de pré-processamento (aqueles que começam por #) estão fora desta regra geral, uma vez que não são declarações. Elas são linhas lidas e processadas pelo pré-processador e não produzem qualquer código por si só. Directivas de pré-processamento deve ser especificado em sua própria linha e não tem que terminar com um ponto e vírgula (;).


comentários


Os comentários são partes do código-fonte desconsiderado pelo compilador. Eles simplesmente não fazer nada. Sua finalidade é apenas para permitir ao programador inserir anotações ou descrições dentro do código fonte.

C + + suporta duas maneiras de inserir comentários:



1
2
// linha de comentário
/* Bloco de comentário */ 




O primeiro deles, conhecida como linha de comentário, descarta tudo a partir de onde o par de sinais de barra (/ /) encontra-se até ao fim da mesma linha. O segundo, conhecido como bloco de comentário, descarta tudo entre os caracteres / * ea primeira aparição do * / personagens, com a possibilidade de incluir mais de uma linha.
Nós vamos adicionar comentários ao nosso segundo programa:



1
2
3
4
5
6
7
8
9
10
11
12
/* Meu segundo programa em c++, 
mais comentário */

#include <iostream>
using namespace std;

int main ()
{
  cout << "Olá Mundo! ";     // prints Olá Mundo!
  cout << "Eu sou um programa c++"; // prints EU sou um programa c++
  return 0;
}
Olá Mundo! Eu sou um programa
c++





Se você incluir comentários dentro do código-fonte de seus programas sem usar o comentário personagens combinações / /, / * e * /, o compilador irá levá-los como se fossem expressões C + +, provavelmente causando uma ou várias mensagens de erro quando você compilar .


Fonte: http://www.cplusplus.com/doc/tutorial/program_structure/

1_ Instruções para uso

A quem é dirigido este tutorial?
Este tutorial é para aquelas pessoas que querem aprender a programar em C + + e não necessariamente tem qualquer conhecimento prévio de outras linguagens de programação. É claro que qualquer conhecimento de outras linguagens de programação ou qualquer habilidade geral do computador pode ser útil para entender melhor este tutorial, embora não seja essencial.

Também é adequado para aqueles que precisam de uma pequena atualização sobre os novos recursos da linguagem adquiriu a partir dos mais recentes padrões.

Se você estiver familiarizado com a linguagem C, você pode tomar as três primeiras partes deste tutorial como uma revisão de conceitos, uma vez que, principalmente, explicar a parte C do C + +. Existem pequenas diferenças na sintaxe do C + + para algumas características C, então eu ainda recomendo que você lê-los.

A quarta parte descreve a programação orientada a objetos.

A quinta parte principalmente descreve os novos recursos introduzidos pelo ANSI-C + + padrão.

Estrutura deste tutorial
O tutorial é dividido em seis partes principais, e cada parte é dividida em várias seções que cobrem um tópico específico de cada. Você pode acessar qualquer seção diretamente a partir do índice de seção disponível na barra lateral esquerda, ou iniciar o tutorial a partir de qualquer ponto e siga os links na parte inferior de cada seção.

Muitas seções incluem exemplos que descrevem o uso do conhecimento recém-adquirido no capítulo. Recomenda-se a leitura destes exemplos e ser capaz de compreender cada uma das linhas de código que o constituem, antes de passar para o próximo capítulo.

Uma boa maneira de ganhar experiência com a linguagem de programação, modificando e acrescentando novas funcionalidades em seu próprio país para os programas de exemplo que você compreenda plenamente. Não tenha medo de modificar os exemplos fornecidos com este tutorial, que é a maneira de aprender!

Notas de compatibilidade
O ANSI-C + + padrão de aceitação como um padrão internacional é relativamente recente. Foi publicado pela primeira vez em Novembro de 1997, e revisto em 2003. No entanto, a linguagem C + + existe a partir de um longo período de tempo antes (1980). Portanto, há muitos compiladores que não suportam todos os novos recursos incluídos no ANSI-C + +, especialmente aqueles liberados antes da publicação da norma.

Este tutorial é pensado para ser seguido com compiladores modernos que o apoio, pelo menos em algum grau, as especificações ANSI-C + +. Convido você a obter um se o seu não é adaptado. Há muitas opções, tanto comerciais e livre.

Compiladores
Os exemplos incluídos neste tutorial são todos os programas do console. Isso significa que usar o texto para se comunicar com o usuário e para mostrar seus resultados.

Todos os compiladores C + + suportam a compilação de programas de console. Verifique o manual de seu compilador do usuário para mais informações sobre como compilá-los.

Fonte: http://www.cplusplus.com/doc/tutorial/introduction/