Nome: Pequeno Dongdong de Ah Yue
Página inicial do blog: O blog_CSDN de Xiaodongdong de Yue, conhecimento avançado do blog-python&&c++, essencial para o Ano Novo Chinês, blogueiro no campo da explicação do conhecimento C/C++
Índice
membros da estrutura de acesso
Estruturas como argumentos de função
Exemplo de encapsulamento de dados
Primeiro introduza uma função de comparação de strings: strcmp(s1, s2), quando s1<s2, retorna um inteiro negativo; quando s1=s2, o valor de retorno é 0; quando s1>s2, retorna um inteiro positivo e uma função de cópia de String
: strcpy(a, b), significa copiar o valor da string b para a string a, é claro que o comprimento da string b não pode exceder a string a
definir estrutura
Para definir uma estrutura, você deve usar a instrução struct . A instrução struct define um novo tipo de dados que contém vários membros. O formato da instrução struct é o seguinte:
struct type_name {
member_type1 member_name1;
member_type2 member_name2;
member_type3 member_name3;
.
.
} object_names;
type_name é o nome do tipo de estrutura, member_type1 member_name1 é uma definição de variável padrão, como int i; ou float f; ou outras definições de variáveis válidas. No final de uma definição de estrutura, antes do ponto e vírgula final, você pode especificar uma ou mais variáveis de estrutura, isso é opcional. O seguinte é para declarar um tipo de estrutura Books , a variável é book :
struct Books
{
char title[50];
char author[50];
char subject[100];
int book_id;
} book;membros da estrutura de acesso
Para acessar os membros de uma estrutura, usamos o operador de acesso a membros (.) . O operador de acesso ao membro é um ponto entre o nome da variável da estrutura e o membro da estrutura que queremos acessar.
O exemplo a seguir demonstra o uso da estrutura:
#include <iostream>
#include <cstring>
using namespace std;
// 声明一个结构体类型 Books
struct Books
{
char title[50];
char author[50];
char subject[100];
int book_id;
};
int main( )
{
Books Book1; // 定义结构体类型 Books 的变量 Book1
Books Book2; // 定义结构体类型 Books 的变量 Book2
// Book1 详述
strcpy( Book1.title, "C++ 教程");
strcpy( Book1.author, "Runoob");
strcpy( Book1.subject, "编程语言");
Book1.book_id = 12345;
// Book2 详述
strcpy( Book2.title, "CSS 教程");
strcpy( Book2.author, "Runoob");
strcpy( Book2.subject, "前端技术");
Book2.book_id = 1234556;
// 输出 Book1 信息
cout << "第一本书标题 : " << Book1.title <<endl;
cout << "第一本书作者 : " << Book1.author <<endl;
cout << "第一本书类目 : " << Book1.subject <<endl;
cout << "第一本书 ID : " << Book1.book_id <<endl;
// 输出 Book2 信息
cout << "第二本书标题 : " << Book2.title <<endl;
cout << "第二本书作者 : " << Book2.author <<endl;
cout << "第二本书类目 : " << Book2.subject <<endl;
cout << "第二本书 ID : " << Book2.book_id <<endl;
return 0;
}O exemplo define o tipo de estrutura Books e suas duas variáveis Book1 e Book2. Quando o código acima é compilado e executado, ele produz o seguinte resultado:
Título do primeiro livro: Tutorial C++ Autor do primeiro livro: Runoob Categoria do primeiro livro: Linguagem de programação ID do primeiro livro: 12345 Título do segundo livro: Tutorial CSS Segundo livro Autor: Runoob Categoria do segundo livro: Tecnologia de front-end O segundo livro ID: 1234556
Estruturas como argumentos de função
Você pode usar uma estrutura como um parâmetro de função e o método de passagem de parâmetros é semelhante a outros tipos de variáveis ou ponteiros. Você pode usar o exemplo acima para acessar variáveis de estrutura:
#include <iostream>
#include <cstring>
using namespace std;
void printBook( struct Books book );
// 声明一个结构体类型 Books
struct Books
{
char title[50];
char author[50];
char subject[100];
int book_id;
};
int main( )
{
Books Book1; // 定义结构体类型 Books 的变量 Book1
Books Book2; // 定义结构体类型 Books 的变量 Book2
// Book1 详述
strcpy( Book1.title, "C++ 教程");
strcpy( Book1.author, "Runoob");
strcpy( Book1.subject, "编程语言");
Book1.book_id = 12345;
// Book2 详述
strcpy( Book2.title, "CSS 教程");
strcpy( Book2.author, "Runoob");
strcpy( Book2.subject, "前端技术");
Book2.book_id = 1234556;
// 输出 Book1 信息
printBook( Book1 );
// 输出 Book2 信息
printBook( Book2 );
return 0;
}
void printBook( struct Books book )
{
cout << "书标题 : " << book.title <<endl;
cout << "书作者 : " << book.author <<endl;
cout << "书类目 : " << book.subject <<endl;
cout << "书 ID : " << book.book_id <<endl;
}Quando o código acima é compilado e executado, ele produz o seguinte resultado:
Título do livro: C++ Tutorial Autor do livro: Runoob Categoria do livro: Linguagem de programação ID do livro: 12345 Título do livro: Tutorial de CSS Autor do livro: Runoob Categoria do livro: Tecnologia Front-End ID do livro: 1234556
ponteiro para estrutura
Você pode definir ponteiros para estruturas de maneira semelhante a ponteiros para variáveis de outros tipos, como segue:
struct Livros *struct_pointer;
Agora você pode armazenar o endereço da variável de estrutura na variável de ponteiro definida acima. Para encontrar o endereço de uma variável de estrutura, coloque o operador & na frente do nome da estrutura, assim:
struct_pointer = &Livro1;
Para acessar um membro de uma estrutura usando um ponteiro para essa estrutura, você deve usar o operador -> da seguinte maneira:
struct_pointer->título;
Vamos reescrever o exemplo acima usando ponteiros struct, isso ajudará você a entender o conceito de ponteiros struct:
#include <iostream>
#include <cstring>
using namespace std;
void printBook( struct Books *book );
struct Books
{
char title[50];
char author[50];
char subject[100];
int book_id;
};
int main( )
{
Books Book1; // 定义结构体类型 Books 的变量 Book1
Books Book2; // 定义结构体类型 Books 的变量 Book2
// Book1 详述
strcpy( Book1.title, "C++ 教程");
strcpy( Book1.author, "Runoob");
strcpy( Book1.subject, "编程语言");
Book1.book_id = 12345;
// Book2 详述
strcpy( Book2.title, "CSS 教程");
strcpy( Book2.author, "Runoob");
strcpy( Book2.subject, "前端技术");
Book2.book_id = 1234556;
// 通过传 Book1 的地址来输出 Book1 信息
printBook( &Book1 );
// 通过传 Book2 的地址来输出 Book2 信息
printBook( &Book2 );
return 0;
}
// 该函数以结构指针作为参数
void printBook( struct Books *book )
{
cout << "书标题 : " << book->title <<endl;
cout << "书作者 : " << book->author <<endl;
cout << "书类目 : " << book->subject <<endl;
cout << "书 ID : " << book->book_id <<endl;
}Quando o código acima é compilado e executado, ele produz o seguinte resultado:
Título do livro: C++ Tutorial Autor do livro: Runoob Categoria do livro: Linguagem de programação ID do livro: 12345 Título do livro: Tutorial de CSS Autor do livro: Runoob Categoria do livro: Tecnologia Front-End ID do livro: 1234556
palavra-chave typedef
Aqui está uma maneira mais simples de definir estruturas onde você pode "apelidar" o tipo que você cria. Por exemplo:
typedef struct Livros
{
char title[50];
char autor[50];
char assunto[100];
int book_id;
}Livros;
Agora, você pode usar Books diretamente para definir variáveis do tipo Books sem usar a palavra-chave struct. Aqui está um exemplo:
Livros Livro1, Livro2;
Você pode usar a palavra-chave typedef para definir tipos não struct da seguinte forma:
typedef long int *pint32; pint32 x, y, z;
x, y e z são todos ponteiros para long int.
Encapsulamento de dados C++
Todos os programas C++ têm os dois elementos básicos a seguir:
- Declarações do programa (código): são as partes do programa que executam ações e são chamadas de funções.
- Dados do programa: Os dados são informações do programa e serão afetados pelas funções do programa.
O encapsulamento é um conceito em programação orientada a objetos que vincula dados e funções que manipulam dados, de modo que possam evitar interferências e uso indevido do mundo externo, garantindo assim a segurança. O encapsulamento de dados leva a outro conceito OOP importante, a ocultação de dados .
O encapsulamento de dados é um mecanismo que liga dados e funções que manipulam dados juntos, e a abstração de dados é um mecanismo que apenas expõe interfaces para usuários e oculta detalhes de implementação específicos.
C++ suporta encapsulamento e ocultação de dados (públicos, protegidos, privados) criando classes . Já sabemos que uma classe contém membros privados, membros protegidos e membros públicos. Por padrão, todos os itens definidos em uma classe são privados. Por exemplo:
class Box
{
public:
double getVolume(void)
{
return length * breadth * height;
}
private:
double length; // 长度
double breadth; // 宽度
double height; // 高度
};As variáveis comprimento, largura e altura são todas privadas. Isso significa que eles só podem ser acessados por outros membros da classe Box, não por outras partes do programa. Essa é uma maneira de obter o encapsulamento.
Para tornar os membros de uma classe públicos (ou seja, acessíveis a outras partes do programa), eles devem ser declarados com a palavra-chave public antes deles. Todas as variáveis ou funções definidas após o identificador público podem ser acessadas por todas as outras funções do programa.
Definir uma classe como uma classe amiga de outra classe expõe detalhes de implementação e reduz o encapsulamento. Idealmente, os detalhes de implementação de cada classe devem ser escondidos do mundo exterior tanto quanto possível.
Exemplo de encapsulamento de dados
Em um programa C++, qualquer classe com membros públicos e privados pode ser usada como uma instância de encapsulamento e abstração de dados. Veja o exemplo abaixo:
#include <iostream>
using namespace std;
class Adder{
public:
// 构造函数
Adder(int i = 0)
{
total = i;
}
// 对外的接口
void addNum(int number)
{
total += number;
}
// 对外的接口
int getTotal()
{
return total;
};
private:
// 对外隐藏的数据
int total;
};
int main( )
{
Adder a;
a.addNum(10);
a.addNum(20);
a.addNum(30);
cout << "Total " << a.getTotal() <<endl;
return 0;
}Quando o código acima é compilado e executado, ele produz o seguinte resultado:
Total 60
A classe acima adiciona números e retorna a soma. Os membros públicos addNum e getTotal são interfaces externas e os usuários precisam conhecê-los para usar a classe. O total de membros privados está oculto do mundo exterior e os usuários não precisam saber sobre isso, mas é necessário para que a classe funcione corretamente.
Estratégia de design
Em circunstâncias normais, definiremos o estado do membro da classe como private (private), a menos que realmente precisemos expô-lo, para garantir um bom encapsulamento .
Isso geralmente se aplica a membros de dados, mas se aplica igualmente a todos os membros, incluindo funções virtuais.
Classes e objetos C++
C++ adiciona programação orientada a objetos à linguagem C, e C++ suporta programação orientada a objetos. As classes são um recurso central do C++ e geralmente são chamadas de tipos definidos pelo usuário.
Uma classe é usada para especificar a forma de um objeto e é um tipo de dados definido pelo usuário, que é uma combinação de dados e funções encapsulados. Os dados em uma classe são chamados de variáveis de membro e as funções são chamadas de funções de membro. Uma classe pode ser considerada um modelo que pode ser usado para criar vários objetos com as mesmas propriedades e comportamento.
Definição de classe C++
Para definir uma classe, você precisa usar a palavra-chave class, então especificar o nome da classe, e o corpo da classe é colocado entre um par de chaves. O corpo contém as variáveis de membro e as funções de membro da classe.
Definir uma classe é essencialmente um projeto para definir um tipo de dados, que define o que o objeto da classe inclui e quais operações podem ser executadas nesse objeto.
No exemplo a seguir, usamos a palavra-chave class para definir o tipo de dados Box, que contém três variáveis de membro comprimento, largura e altura:
class Box
{
public:
double length; // 盒子的长度
double breadth; // 盒子的宽度
double height; // 盒子的高度
};A palavra-chave public determina os atributos de acesso dos membros da classe. Dentro do escopo do objeto de classe, os membros públicos são acessíveis fora da classe. Você também pode especificar os membros da classe como private ou protected , o que explicaremos mais adiante.
Definir um objeto C++
As classes fornecem o modelo para objetos, então, basicamente, os objetos são criados com base em classes. Objetos de classes são declarados como variáveis de tipos primitivos. A declaração a seguir declara dois objetos da classe Box:
Box Box1; // Declara Box1, digita Box Box Box2; // Declara Box2, digita Box
Os objetos Box1 e Box2 têm seus respectivos membros de dados.
acessar membros de dados
Membros de dados públicos de objetos de uma classe podem ser acessados usando o operador de acesso direto ao membro.
Para entender melhor esses conceitos, vamos tentar o seguinte exemplo:
#include <iostream>
using namespace std;
class Box
{
public:
double length; // 长度
double breadth; // 宽度
double height; // 高度
// 成员函数声明
double get(void);
void set( double len, double bre, double hei );
};
// 成员函数定义
double Box::get(void)
{
return length * breadth * height;
}
void Box::set( double len, double bre, double hei)
{
length = len;
breadth = bre;
height = hei;
}
int main( )
{
Box Box1; // 声明 Box1，类型为 Box
Box Box2; // 声明 Box2，类型为 Box
Box Box3; // 声明 Box3，类型为 Box
double volume = 0.0; // 用于存储体积
// box 1 详述
Box1.height = 5.0;
Box1.length = 6.0;
Box1.breadth = 7.0;
// box 2 详述
Box2.height = 10.0;
Box2.length = 12.0;
Box2.breadth = 13.0;
// box 1 的体积
volume = Box1.height * Box1.length * Box1.breadth;
cout << "Box1 的体积：" << volume <<endl;
// box 2 的体积
volume = Box2.height * Box2.length * Box2.breadth;
cout << "Box2 的体积：" << volume <<endl;
// box 3 详述
Box3.set(16.0, 8.0, 12.0);
volume = Box3.get();
cout << "Box3 的体积：" << volume <<endl;
return 0;
}Quando o código acima é compilado e executado, ele produz o seguinte resultado:
Volume da Caixa1: 210 Volume da Caixa2: 1560 Volume da Caixa3: 1536
Observe que membros privados e protegidos não podem ser acessados diretamente usando o operador de acesso de membro direto (.). Aprenderemos como acessar membros privados e protegidos em tutoriais subsequentes.
escreva no final
Febre, desconfortável, mas como não posto blog há muito tempo, peguei minhas anotações da aula e fui dormir, tchau