Programação Orientada a Objetos C++ (2ª Edição) Capítulo 1 (Conhecimento Preliminar de C++) Resumo dos Pontos de Conhecimento

Programação orientada a objetos C++

参考书目：《C++面向对象程序设计》—— 谭浩强 《C++程序设计：思想与方法》—— 翁惠玉

---

---

1. De C a C++

       A linguagem C é uma linguagem estruturada e modular. O projetista de um programa C deve projetar cuidadosamente cada detalhe do programa e considerar com precisão o que acontece em cada momento quando o programa está sendo executado. Quando o tamanho do programa aumenta, os programas estruturados O design parece inadequado .
       Para resolver a crise do design de software, a ideia de programação orientada a objetos (OOP) foi proposta na década de 1980. Na prática, as pessoas descobriram que a linguagem C é tão amplamente utilizada que se uma linguagem orientada a objetos for desenvolvida com base nela, com certeza fará com que fosse fácil para o público aceitar essa linguagem, então nasceu o C++.
       C++ pode ser usado tanto para programação estruturada orientada a processos quanto para programação orientada a objetos.

2. Regras lexicais e lexicais da linguagem C++

1.Conjunto de caracteres da linguagem C++

       Conjunto de caracteres equivalente à linguagem C, incluindo:

• Letras inglesas maiúsculas e minúsculas
• Caracteres numéricos
• Outros caracteres ASCII (exceto @, $)

2. Palavras e regras lexicais

       As palavras são um dos principais componentes que compõem uma declaração. Geralmente consistem em vários caracteres. C++ tem vários tipos de palavras:

• Palavras-chave
         são palavras de comando na linguagem C++. São palavras predefinidas e o compilador C++ tem uma interpretação especial delas. Tais como: int, float, if, else, while, switch, etc.
• Identificadores
         Os programadores usam identificadores para nomear elementos no programa, incluindo nomes de funções, nomes de classes, nomes de objetos, nomes de tipos, nomes de variáveis, nomes de variáveis ​​constantes, nomes de arrays, etc. Os identificadores começam com letras ou sublinhados, seguidos por letras, números e sublinhados (os identificadores diferenciam maiúsculas de minúsculas) .
• Operador
         Um operador é uma palavra que representa uma determinada operação e consiste em um ou mais caracteres (observe a prioridade e a ordem de combinação dos operadores) .
• Delimitadores
         devem ser usados ​​para separar palavras-chave e identificadores em instruções e entre instruções. Os delimitadores comumente usados ​​em C++ incluem espaços, vírgulas, ponto e vírgula, dois pontos e colchetes.
• Comentário
         C++ fornece dois caracteres de comentário. /* Comentários* / (Comentários de várias linhas) // Comentários (Comentários de uma linha)

3. O programa C++ mais simples

1. Caracteres de saída

Exemplo 1: Produza uma linha de caracteres "Este é um programa C++."

#include <iostream>          //用cout输出时需要用此头文件
using namespace std;        //使用命名空间std
int main()
{
    
    
    cout<<"This is a C++ program.\n";      //用C++的方法输出一行
    return 0;
}

注： (1)C++程序中常用cout、cin进行输出输入，cout是C++定义的输出流对象，<<是插入运算符。 (2)使用cout、cin需要用头文件iostream，在程序开始要用#include声明包含的头文件。 (3) using namespace std; 意思是使用命名空间。C++标准库中的类和函数是在命名空间std中声明的，因此程序中如用C++标准库中的有关内容，就要用using namespace std; 语句声明。 (4)标准C++规定main函数必须声明为int类型，如果程序正常运行，向操作系统返回一个零值，否则返回非零值，通常是-1。

2. Operações numéricas

Exemplo 2: Encontre a soma de dois números a e b

#include <iostream>        //预处理命令
using namespace std;      //使用命名空间std
int main()                    //主函数首部
{
    
                                 //函数体开始
    int a,b,sum;              //定义变量
    cin>>a>>b;                //输入语句
    sum=a+b;                  //赋值语句
    cout<<"a+b="<<sum<<endl;      //输出语句
    return 0;                    //如程序正常结束，返回一个零值
}

注： (1)在程序执行时，键盘输入的第一个数据赋予a，第二个数据赋予b 。 (2)cout语句中的endl是C++控制符常数，作用是让光标换行。

3. Comparação numérica

Exemplo 3: Encontre o maior de dois números

#include <iostream>
using namespace std;
int main()
{
    
     
    int max(int x,int y) ;         //对max函数作声明
    int a,b,c;
    cin>>a>>b;
    c=max(a,b);                   //调用max函数
    cout<<"max="<<c<<endl;
    return 0;
}
int max(int x,int y)            //定义max函数
{
    
     
    int z;
    if(x>y) z=x;
    else z=y;
    return(z);
}

注： (1)本程序包含两个函数，主函数main和被调用的函数max。 (2)max函数的作用是将两个整数中的大数赋予变量z。return语句将z的值返回给主函数main。返回值是通过函数名max带回到main函数的调用处。

4. Classe C++

Exemplo 4: programa C++ contendo classes

#include <iostream>                 
using namespace std;
class Student             //声明一个类，类名为Student
{
    
      
   private:                   //以下为类中的私有部分
      int num;                //私有变量num
      int score;             //私有变量score
   public:                   //以下为类中公用部分
   void setdata()           //定义公用函数setdata
    {
    
    cin>>num;              //输入num的值
     cin>>score;}          //输入score的值
   void display()          //定义公用函数display
    {
    
    cout<<"num="<<num<<endl;          //输出num的值
     cout<<"score="<<score<<endl;};   //输出score的值
};                                    //类的声明结束
Student stud1,stud2;      //定义stud1和stud2为Student类的变量，称为对象
int main()               //主函数首部
{
    
    
    stud1.setdata();   //调用对象stud1的setdata函数
    stud2.setdata();   //调用对象stud2的setdata函数
    stud1.display();   //调用对象stud1的display函数
    stud2.display();   //调用对象stud1的display函数
    return 0;
}

注： (1)程序中声明一个被称为类的类型Student。声明时要用关键字class。C++类中可以包含数据(如变量num、 score)和函数(如setdata函数和 display函数)，分别称为数据成员和成员函数。 (2)在C++ 中将一组数据和访问这组数据的函数封装在一起，组成类。一个类是由一组数据，一组对其访问的若干函数，以及数据和函数的访问属性组成的。在前面程序中看到的private（私有）public（公有）保留字代表数据和函数的访问属性。 (3)凡是指定为公有的数据和函数，既可由本类的函数访问和调用，也可由其他函数或语句访问和调用；凡是指定为私有的数据和函数，通常只能由本类的函数访问和调用。 (4)程序中“Student stud1,stud2; ”是一个定义语句，定义两个Student 类型变量stud1和stud2，Student 类与int一样是C++的合法类型。 (5)具有“类”类型的变量称为对象。 Student的对象stud1，stud2具有同样的结构和特征。 (6)在类外调用成员函数时必须在函数名前冠以类的名称。

4. Extensão C++ para C

       Para ser compatível com C, C++ mantém alguns regulamentos na linguagem C, como o nome do arquivo de cabeçalho. A extensão do arquivo de cabeçalho na linguagem C é .h. Muitos sistemas de compilação C++ mantêm essa extensão. O Compilador C++ lançado nos últimos anos A nova versão do sistema introduziu uma série de arquivos de cabeçalho sem extensões, como iostream, string, cmath, etc. Para compatibilidade com C++, arquivos de cabeçalho com extensões ainda são permitidos. Como a linguagem C não possui namespace, você não precisa usar namespace std ao usar arquivos de cabeçalho com extensões.
       C++ herda a maioria das funções e disposições gramaticais fornecidas pela linguagem C e se expande com base nisso.

1.Entrada e saída de C++

       Para conveniência de uso, C++ não apenas usa as funções printf e scanf para entrada e saída, mas também adiciona o fluxo de entrada padrão e o fluxo de saída cin e cout. Eles são definidos no arquivo de cabeçalho iostream. O fluxo padrão é um arquivo de streaming que pode ser operado diretamente sem abrir e fechar o arquivo. O fluxo de entrada padrão aqui se refere à entrada de dados do teclado, e o fluxo de saída padrão refere-se ao saída de tela.fluxo de dados.

• Use cout para
  o formato de saída: cout <<Expressão 1[<<Expressão 2...]
  Função: Calcule o valor da expressão um por um, da esquerda para a direita, e insira-o no fluxo de saída cout.
  Uso: cout deve ser usado junto com o operador de saída <<. Cada << é seguido por uma expressão. A direção de combinação do operador << é da esquerda para a direita, portanto os valores de cada expressão são inseridos na sequência da esquerda para a direita no fluxo de saída.
• Use cin para
  formato de entrada: cin>>Variável 1 [>>Variável 2...]
  Função: >> é o operador de extração de C++, o que significa obter dados do dispositivo de entrada padrão e atribuí-los às variáveis ​​subsequentes.
  Uso: Ao inserir dados numéricos pelo teclado, separe os dois dados com um espaço ou retorno de carro.
  

2. Use const para definir variáveis ​​constantes

       Formato: const tipo nome da variável = constante
       Exemplo: const float PI= 3.14159;

3. Declaração de protótipo de função

       Formato: tipo de função nome da função (lista formal de parâmetros),
       exemplo: int max (int x, int y);

4. Sobrecarga de funções

       C++ permite que múltiplas funções sejam definidas com um nome de função no mesmo domínio.Essas funções têm diferentes números de parâmetros e diferentes tipos de parâmetros. Usar um nome de função para implementar funções diferentes é chamado de sobrecarga de função.

Exemplo: Calcule o número máximo entre três números (tipo sobrecarga)

#include <iostream>
using namespace std;
int max(int a,int b,int c)           //求3个整数中的最大者
{
    
     if (b>a) a=b;
if (c>a) a=c;
return a; 
} 
float max(float a,float b, float c)  //求3个实数中的最大者
{
    
    if (b>a) a=b;
 if (c>a) a=c;
 return a; 
} 
long max(long a,long b,long c)  //求3个长整数中的最大者
{
    
    if (b>a) a=b;
 if (c>a) a=c;
 return a;
}
int main( )
{
    
    int a,b,c;  float d,e,f;  long g,h,i;
cin>>a>>b>>c; 
cin>>d>>e>>f;
cin>>g>>h>>i;
int m;
m= max(a,b,c);                        //函数值为整型
cout <<"max_i="<<m<<endl;
float n;
n=max(d,e,f);                          //函数值为实型
cout<<"max_f="<<n<<endl;
long int p;
p=max(g,h,i);                          //函数值为长整型
cout<<"max_l="<<p<<endl;
return 0;
}

Exemplo: Calcule o número máximo entre três números (sobrecarga de função)

#include <iostream>
using namespace std;
int max(int a,int b,int c)     //求3个整数中的最大者
{
    
    if (b>a) a=b;
 if (c>a) a=c;
 return a;
}
int max(int a, int b)         //求两个整数中的最大者
{
    
    if (a>b) return a;
 else return b;
}
int main( )
{
    
    int a=7,b=-4,c=9;
 cout<<max(a,b,c)<<endl; //输出3个整数中的最大者
 cout<<max(a,b)<<endl;  //输出两个整数中的最大者
 return 0;
}

注：不允许函数参数个数、参数类型都相同，只是函数返回值不同。因为系统无法从调用形式上判断调用与哪个函数相匹配。

5. Modelo de função

       Se o número de parâmetros de duas funções for o mesmo, o comportamento da função é o mesmo (faz a mesma coisa), mas os tipos de dados da função e dos parâmetros são diferentes. Se você usar sobrecarga de função, o código da função escrito será o mesmo.Para economizar tempo, C++ fornece funcionalidade de modelo de função.
       Formato: identificador de nome de tipo de modelo [, identificador de nome de tipo, ...]
       Função: O chamado modelo de função serve para criar uma função geral sem especificar o tipo de função e o tipo de parâmetro, mas usando um tipo virtual para representá-la. Ao chamar uma função, os tipos virtuais no modelo são substituídos pelos tipos dos parâmetros reais.

Exemplo: Definir um modelo de função para calcular o maior de dois números

#include <iostream>
using namespace std;
template <typename T>
T max(T a,T b,T c)  //用虚拟类型T表示类型
{
    
    if(b>a) a=b;
 if(c>a) a=c;
 return a;
}
int main()
{
    
    int i1=8,i2=5,i3=6,i;
 double d1=56.9,d2=90.765,d3=43.1,d;
 long g1=67843,g2=-456,g3=78123,g;
 i=max(i1,i2,i3);
 d=max(d1,d2,d3);
 g=max(g1,g2,g3);
 cout<<"i_max="<<i<<endl;
 cout<<"d_max="<<d<<endl;
cout<<"g_max="<<g<<endl;
 return 0;
}

注：函数模板只适用于函数参数的个数相同而类型不同，并且函数体相同的情况，如果函数的参数个数不同，则不能用函数模板。

6. Funções com parâmetros padrão

       C++ permite definir valores padrão para parâmetros de função.Quando a função é chamada, se não houver parâmetros reais, o valor padrão será usado como o valor real do parâmetro.
       Formato: Tipo de parâmetro formal Nome da variável de parâmetro formal = constante
       Função: Ao chamar uma função, se não houver parâmetro real, a constante será usada como o valor do parâmetro formal; se houver um parâmetro real, o valor do parâmetro real parâmetro ainda será usado como o valor do parâmetro formal.

Exemplo: Escreva uma função para calcular o volume do
flutuador de um cilindro (flutuador h, flutuante r = 12,5)

调用可以采用以下任何一种形式：
	volume( 45.6);
	volume( 32.5, 10.5);
	用第一种方式调用时，只有一个实参，圆半径的值取默认值12.5.
	用第二种方式调用时，有两个实参，圆半径的值取实参的值10.5。

注： (1)有默认值的形参必须放在形参表的右边，不允许无默认参数值和有默认参数值的形参交错排列。 (2)一个函数名不能同时用于重载函数和带默认形参值的函数。当调用函数时，如少写一个参数，系统无法判断是利用重载函数还是利用带默认参数值的函数，出现二义性。

7. Referência a variáveis

       C++ fornece a função de alias de variáveis, que é a referência de variáveis.
       Formato: Tipo e Variável 1 = Variável 2
       Variável 2 é uma variável que foi definida anteriormente e tem o mesmo tipo da variável 1. Aqui, uma variável de alias 1 é definida para a variável 2. No programa, a variável 1 e a variável 2 são a mesma variável.

#include <iostream>
using namespace std;
int main( )
{
    
    int a=10;
 int &b=a;    //声明b是a的引用
 a=a*a;       //a的值变化了，b的值也应一起变化
 cout<<a<<"  "<<b<<endl;   
 b=b/5;        //b的值变化了，a的值也应一起变化
 cout<<b<<"  "<<a<<endl;
 return 0;
}

注：两个变量不能用同一个别名。
       Além de usar variáveis ​​comuns e variáveis ​​de ponteiro como parâmetros formais, C++ também pode usar variáveis ​​de referência como parâmetros formais.
       (1) Quando variáveis ​​​​comuns são usadas como parâmetros formais
       , o valor do parâmetro real é passado. Na função, os parâmetros formais e reais são duas unidades de memória diferentes. A modificação dos parâmetros formais não afetará o valor do parâmetro real .

#include <iostream>
using namespace std;
void swap(int a,int b)
{
    
     int temp;
 temp=a;
 a=b;
 b=temp;                //  实现a和b的值互换
}
int main( )
{
    
    int i=3,j=5;
 swap(i,j);
 cout<<i<<","<<j<<endl;   //  i和j的值未互换
 return 0;
}

       (2) Usando variáveis ​​​​de ponteiro como parâmetros formais
       A linguagem C também permite o uso de variáveis ​​​​de ponteiro como parâmetros formais.Neste momento, o endereço (ponteiro) da variável de parâmetro real é passado, e esse ponteiro é usado para acessar a variável de parâmetro real dentro do função.

#include <iostream>
using namespace std;
void swap(int *p1,int *p2)
{
    
    int temp;
 temp=*p1;
 *p1= *p2;
 *p2=temp;
}
int main( )
{
    
    int i=3,j=5;
 swap(&i,&j);
 cout<<i<<","<<j<<endl;
 return 0;
}

       (3) Use variáveis ​​de referência como parâmetros formais
       e variáveis ​​de ponteiro como parâmetros formais.Ele passa o endereço da variável de parâmetro real para o parâmetro formal e usa o método "* variável de ponteiro" para acessar a variável de parâmetro real dentro da função. Sabemos que variáveis ​​de referência são apelidos de variáveis. Ao chamar uma função, o parâmetro formal feito pela variável de referência se torna o apelido da variável de parâmetro real. O nome do parâmetro formal usado na função é o apelido do parâmetro real. Este é mais conveniente do que usar variáveis ​​de ponteiro. Intuitivo e mais conveniente.

#include <iostream>
using namespace std;
void swap(int &a,int &b)
{
    
    int temp;
 temp=a;
 a=b;
 b=temp;
}
int main( )
{
    
    int i=3,j=5;
 swap(i,j);
 cout<<"i="<<i<<"   "<<"j="<<j<<endl;
 return 0;
}

注： (1)引用变量都具有非void类型 (2)不能建立引用的数组 (3)可以建立常引用变量，不允许修改常引用变量的值

8. Funções integradas

       C++ fornece um mecanismo para incorporar o código da função chamada no código da função de chamada durante a compilação, eliminando o link de chamada ao executar a função e melhorando a velocidade de execução da função. Esse mecanismo é chamado de função integrada e alguns livros o chamam de função embutida.
       Formato: tipo de função inline nome da função (lista de parâmetros formal)
                  {corpo da função}
       Formato de chamada: nome da função (lista de parâmetros real)

Exemplo: Calcule raízes quadradas usando funções integradas

#include <iostream>
using namespace std;
inline int power(int x)       //定义内置函数
{
    
    return x*x;}
int main()
{
    
    cout<<power(2)<<endl;
 cout<<power(1+1)<<endl;
 return 0;
}

注：使用内置函数可以节省程序的运行时间，但增加了目标程序的长度。所以在使用时要衡量时间和空间的得失。

9. Operador de escopo

       Cada variável tem seu próprio escopo efetivo. O programa só pode usar variáveis ​​dentro do escopo efetivo da variável e não pode usar variáveis ​​diretamente em outros domínios.

Exemplo: variáveis ​​locais e variáveis ​​globais têm o mesmo nome

#include <iostream>
	using namespace std;
	float a=13.5;
	int main( )
	{
    
        int a=5;
	     cout<<a<<endl;
	     return 0;    }

       Existem duas variáveis ​​a no programa, uma é uma variável global e a outra é uma variável local da função principal.De acordo com a regra de que variáveis ​​locais irão mascarar variáveis ​​globais com o mesmo nome, a variável a que aparece na função é uma variável local, então o valor de saída é 5, em vez de 13,5, para acessar variáveis ​​globais em uma função, C++ fornece o operador de escopo::, que pode ser usado para especificar o escopo a ser acessado. A função principal pode ser reescrito como

#include <iostream>
	using namespace std;
	float a=13.5;
	int main( )
	{
    
    int a=5;
	cout<<a<<endl;
	cout<<::a<<endl;
	 return 0;
	}
	::a表示全局变量a。注意不能用::访问局部变量。

10. Variáveis ​​de string

       C++ fornece o tipo de classe de string string. Na verdade, não é um tipo básico de C++. É uma classe de string declarada na biblioteca padrão C++, e os programas podem usá-la para definir objetos.

• Definir
  formato de variável de string: tabela de nomes de variáveis ​​de string;
  注：如用字符串变量，在程序开始要用包含语句把C++标准库的string头文件包含进来。
• Executar operações de string
  (1) Atribuir um valor a uma variável de string Variável de string
  = Expressão de string
  
  (2) Acessar caracteres em uma string
  C++ permite que strings sejam usadas como matrizes de caracteres. O subscrito do primeiro caractere é 0, e o subscrito do primeiro caractere é 0. o segundo caractere é 0. O subscrito dos caracteres é 1 e assim por diante.

string  w = "then";
 	    w[2] = "a";

       (3) String de entrada e saída
       cin >> Variável de string
       cout << Variável de string
       (4) Formato de operação de conexão de string
       : String 1 + String 2

string  st1=“C++”;
string  st2=“Language”;
st1 = st1 + st2 ;

       (5) As operações de comparação de strings
       podem usar os operadores relacionais >, >=, ==, !=, <, <= para comparar caracteres na mesma posição em duas strings e determinar o tamanho dos caracteres com base no valor do código ASCII .

”china” > “chinese”
运算结果是假。

11. Operadores para alocação/destruição dinâmica de memória

       Formato: novo tipo [(valor inicial)]
       O tipo é o elemento chave que determina o tamanho do espaço alocado. Se o resultado da operação estiver correto, seu valor será o endereço inicial do espaço de memória alocado, caso contrário será retornado NULL.
       Formato: delete[] A variável de ponteiro
       exclui o espaço de memória dinâmica apontado pela variável de ponteiro. O tipo de dados da variável de ponteiro determina o tamanho do espaço.

Exemplo: Use memória dinâmica para armazenar variáveis ​​de estrutura

#include <iostream>
#include <string.h>
using namespace std;
struct student 
{
    
    char name [10];
 int num;
 char sex;
};
int main ( )
{
    
    student *p;
 p=new student;
 strcpy_s(p->name,"Wang Fun");
 p->num=10123;
 p->sex='M';
 cout<<p->name<<"  "<<p->num<<"  "<<p->sex<<endl;
 delete p;
 return 0;
}

5. Escrita e implementação de programas C++