Orientado a objetos (oo): los objetos se dividen en última instancia en dos elementos: atributos (que indican las características de su clase, variables en la clase) y comportamiento (es decir, una acción del objeto que genera y un método en la clase).
1 Encapsulación: Significa combinar las propiedades y métodos del objeto en una unidad de sistema independiente y ocultar los detalles internos del objeto tanto como sea posible.
2 Abstracción: El proceso de abstracción es el proceso de generalizar temas específicos y el proceso de describir uniformemente una clase de temas públicos.
3 Herencia: el objeto de subclase tiene las mismas propiedades y métodos que su clase base.
4 Polimorfismo: se refiere a los atributos y comportamientos definidos en la clase base que son heredados por subclases, pueden tener diferentes tipos de datos o comportamientos de desempeño. (Puedes desarrollar tus características al mismo tiempo)
El animal es una categoría básica, sus subcategorías serán tigres, conejos, etc. Como animal, hay un comportamiento definido como Move (), luego estas subclases adoptarán diferentes métodos Move () personalizados (caminar, volar, etc.) según sus propias características luego de heredar.
Programa de lenguaje C de suma de matrices:
Dado que el nombre de la matriz es la dirección de su primer elemento, la matriz y el puntero tienen algunas correlaciones, pero no son completamente equivalentes.
#include<stdio.h>
#include<iostream>
int addArray(int arr[],int n);
using namespace std;
int main()
{
int data[] = { 0,1,2,3,4,5,6,7,8,9 };
int size = sizeof(data) / sizeof(data[0]);
printf("实参数组data大小：%d\n", sizeof(data));//1输出40（是整个数组的长度）
printf("和为：%d\n", addArray(data,size));//4为什么没有当作一个数组？
//因为这里传过来他是把它当作一个地址，她不可能说把整个数组元素都传过来，这样效率太慢了。
//（因为数组是连续存放的，他不如把第一个元素的地址当作指针传过去，接着你要索引依次递推索引到你需要的元素）
//所以在3处实参传递的时候它是当指针传过来的
return 0;
}
int addArray(int arr[], int n)//3所以在整个整个函数里面所有的srr其实被当成一个指针
{
int i , sum = 0;
printf("形参数组arr大小：%d\n", sizeof(arr));//2输出8（8个字节）（是一个指针变量的长度）（是一个地址长度）（因为在64为系统里面就是8个字节存放一个地址）
for (i = 0; i < n; i++)
{
sum += arr[i];
cout << sum << endl;
}
return sum;
}Cambialo:
#include<stdio.h>
#include<iostream>
int addArray(int *arr,int n);//不定义为一个数组了直接定义为一个指针
using namespace std;//名称空间。C++标准库所使用的所有标识符（类，函数，对象等的名称都是在一个同一个特殊的名称空间（std中来定义））
int main()
{
int data[] = { 0,1,2,3,4,5,6,7,8,9 };
int size = sizeof(data) / sizeof(data[0]);
printf("和为：%d\n", addArray(data,size));//传过来传一个地址过来（因为数组名就相当于数组的首地址）
//cout<<"结果是："<<addArray(data,size)<<endl;//endl是回车加清空缓冲区的意思
return 0;
}
int addArray(int *arr, int n)//地址传过来用一个指针接收
{
int i , sum = 0;
for (i = 0; i < n; i++)
{
sum += *arr++;//用指针来索引（arr++是地址递增，前边加*号是取值）
}
return sum;
}Conclusión: declarar los parámetros de una función como una matriz es lo mismo que declarar como un puntero.
El lenguaje C usa printf para lograr resultados, pero printf es una función,
El C ++ anterior usa la salida cout y cout es un objeto. Cout es un objeto de flujo de salida, es la abreviatura de console out (salida de consola), es un objeto que pertenece a la clase basic_ostream, la clase ostream se define en el archivo de encabezado de iostream. (La clase es la colección abstracta de una clase de cosas juntas para formar una clase. Por ejemplo, las personas son una clase, los asiáticos son la herencia de una clase y los chinos son una clase pequeña).
Stream object cin, el tipo de este objeto es istream, él sabe cómo leer los datos del terminal de usuario.
cin >> i; // cin, el operador también se denomina operador de extracción, que a su vez extrae un entero del objeto de flujo de entrada cin. (Se dice que un espacio o la tecla Intro es un número entero).
Cuando el usuario ingresa al teclado, el carácter correspondiente se ingresará en el búfer del teclado del sistema operativo, de modo que cuando el usuario haga clic en la tecla Intro del teclado, el sistema operativo transmita el contenido del búfer del teclado al búfer interno del flujo cin (es decir, stdin stream buffer), el operador ">>" extrae la información requerida de este búfer.
using namespace std; // Espacio de nombres. Todos los identificadores utilizados por la biblioteca estándar de C ++ (los nombres de clases, funciones, objetos, etc. están todos en el mismo espacio de nombres especial (definido en std)) (todas las variables están contenidas en este espacio de nombres, y este espacio debe ser referenciado Variables en, este espacio debe establecerse) (Si no existe tal instrucción, podemos usar la sintaxis std :: cout para llamar al objeto de flujo de salida)
PD: Sobrecargar es darle un nuevo significado a algo viejo. ">>" se definió originalmente como un operador de desplazamiento a la derecha, que está sobrecargado en C ++, y cuando se usa de la manera que se muestra aquí, se usa para extraer información del objeto de flujo de entrada.
El lenguaje C es el mismo que C ++, la cadena termina en 0.
cin.ignore(n);//忽略前n个字符；
cin.getline(buf,n);//获取输入的n个字符（字符串要包含自动后边添加的0所以是一共获取了实际的n-1个），放在buf缓冲区中。
cin.peek();//从字符里面挑取字符
cin.get();//获取字符
cin,gcount();
cin.read();
cout.write();
cout.precision();
cout.width();-------- E / S de archivos:
Escriba un programa de copia de archivos para copiar un archivo a otro. * (Por ejemplo: fileCopy, sourceFile, destFile) (lo que significa que hay un programa fileCopy.exe para copiar source.c a destFile.c)
int main(int argc,char*argv[]);
//在程序中，main有两个参数，整型变量argc和字符指针数组argv[];
//argc的含义是程序的参数数量，包含本身（就是程序自身生成的exe）。
//argv[]的每一个指针指向命令行的一个字符串，所以argv[0]指向字符串“copyFile.exe”,argv[1]指向字符串...，argv[2]指向字符串...。//C语言版本
...
int main(int argc,char* argv)
{
FILE *in,*out;//in和out是我们声明的两个文件指针，它们的类型都是FILE*，分别u走位两个I/O流对象使用（如何理解文件指针，好端端的文件他是存放在磁盘上的，当我们要用到她的时候，必须要暂时把他们拿到内存中，拿到内存中地址是随机分配的，我们不知道地址怎么访问它，我们就必须定义两个指针（因为指针变量里边存放的就是地址），那知道了他的地址才能对他进行操作，所以我们打开之后，就是把地址传给我们定义好的文件指针in和out通过in和out这两个我们就能知道文件的地址，间接能够对文件进行操作）
int ch;
if(argc!=3)//为了确保程序参数个数的正确性
{
fprintf(stderr,"输入形式：copyFile 源文件名 目标文件名\n")//意思就是输入的参数不是三个的话，就要提示输入参数形式为....
}
if((in=fopen(argv[1],"rb"))==NULL)//以二进制可读的方式打开文件并返回文件指针给in
{
fprintf(stderr,"打不开文件：%s\n",argv[1]);//后边两个参数分别是即将被复制的文件和复制后生成的新文件名，先判断这两个文件是否可以打开或者写入
exit(EXIT_FAILURE);//终止
}
if((out=fopen(argv[2],"wb"))=NULL)//以二进制可写的方式打开文件并返回文件指针给out
{
fprintf(stderr,"打不开文件：%s\n",argv[2]);//第三个元素打不开,把这提示信息写入了错误输出流stderr，然后他会自动显示在我们的显示器上，（意思就是未能成功打开我们会像标准错误流stderr发送一条信息）
fclose(in);//因为只有上边打开了你才能执行到这一步，所以打开后要关闭
exit(EXIT_FILURE);
}
//getc()函数从一个输入流（stdin）读取一个字符，putc()函数把这个字符写入到输出流（stdout）
while((ch=getc(in))!=EOF)//EOF其实是个宏定义等于-1（文件的结尾一般都是EOF以-1标志结束）//在这里输入流是这个文件流in,获取一个字符，然后给了字符ch（上边定义的是int型为什么没有定义char呢？因为getc()函数返回值是int类型）
{//到结尾的话就不应进行循环了，因为循环体内的内容就是把这个ch写进out这个文件里面去
if(putc(ch,out)==EOF)//同时进行检查如果他是一个写入文件结尾标志的话他就进行下面语句内容break跳出循环
{
break;
}
}
//(因为上边EOF有两个意思：第一读取错误，第二是文件结束)所以下边两个语句是对文件进行检查，是哪个意思
if(ferror(in))
{
printf("读取文件 %s 失败！\n",argv[1]);
}
if(ferror(in))
{
printf("写入文件 %s 失败！\n",argv[2]);
}
printf("成功复制一个文件！\n");
fclose(in);
fclose(out);//把两个关掉
return 0;
}Versión C ++
#include<Fstream>//是文件流File stream
#include<iostream>//事实Fstream已经包含了iostream
using namespace std;
int main(int agc,char* argv[])
{
ifstream in("test1.txt",ios::in);
if (!in)//如果他返回0的话（就是文件打开失败），再非0就为真
{
cerr << "打开文件1失败" << endl;
return 0;
}
ifstream out("test2.txt",ios::out);
if (!out)//如果他返回0的话（就是文件打开失败），再非0就为真
{
cerr << "打开文件2失败" << endl;
return 0;
}
char x;
while (in >> x)//1">>"这里这个操作符被重载过了,它又变成流了，这种文件里面in流到了这个字符x里边去，每次流一个过去
{
out>> x;//2然后再从x流到cout这个输出终端，最后循环嘛
}
cout << endl;
in.close();//关闭
out.close();
}
#include<Fstream>//是文件流File stream
#incluede<iostream>//事实Fstream已经包含了iostream
using namespace std;
int main()
{
ifstream in;//输入文件流ifstream(input file stream)是Fstream这个头文件报刊的一个类，一个文件输入流的一个类，这个类定义了一个对象in（那么这个in就拥有了这个类的所有功能（属性和函数））。
in.open("test.txt");//in有一个函数就是open
//上边可以将两句合成一句写为：ifstream in("test.txt");//不用open直接带参数的对象
if(!in)//如果他返回0的话（就是文件打开失败），再非0就为真
{
cerr<<"打开文件失败"<<endl;
return0;
}
char x;
while(in>>x)//1">>"这里这个操作符被重载过了,它又变成流了，这种文件里面in流到了这个字符x里边去，每次流一个过去
{
cout<<x;//2然后再从x流到cout这个输出终端，最后循环嘛
}
cout<<endl;
in.close();//关闭
return 0;
}El lenguaje C usa un puntero tipo FILF * para apuntar directamente a la dirección de un archivo en nuestra memoria. En C ++, un objeto se pasa a través de una clase. Este objeto se usa especialmente para la entrada, y luego se accede a través de este objeto. Acceso a la función de miembro para operar en este archivo.
Clase de lectura de archivos: ifstream.
Clase de escritura de archivos: ofstream.
#include<Fstream>//是文件流File stream
#incluede<iostream>//事实Fstream已经包含了iostream
using namespace std;
int main()
{
ofstream out;//类的对象和声明变量是一样的，把out改成其他也行的
out.open("test.txt");//out是指向了test.txt这个文件//打开就是把他从磁盘加载到内存
//上边可以将两句合成一句写为：ofstream out("test.txt");
if(!out)
{
cerr<<"打开文件失败"<<endl;
return0;
}
for(int i=0;i<10;i++)
{
out<<i;//利用循环把0到9,从变量i流到了out指针里面去，流到了out文件里面去（因为上边out是指向了test.txt这个文件）（怎么流呢，看他往哪指就流到哪）（如果源文件里边有东西就会被覆盖掉）
}
cout<<endl;//endl就是回车
out.close();//关闭
return 0;
}Al crear un objeto de las clases ifstream y ofstream, el código anterior pasa el nombre del archivo a su constructor (por el momento entendido como la función (método) utilizada por el objeto por defecto).
Lo anterior también puede aceptar dos parámetros:
ifstream in(char* filename,int open_mode);
//第一个是指针指向了文件名（他是一个字符串）
//open_mode表示打开模式，气质用来定义怎么的反射光hi打开文件（跟open的参数一样）
模式见下图
（什么是文本形式，什么是二进制形式？没有翻译为一堆数据那他就是文本形式）Imagen:
ejemplo:
#include<Fstream>
#incluede<iostream>
using namespace std;
int main()
{
ofstream out("test.txt",ios:app);//就是以添加的形式打开
if(!out)
{
cerr<<"打开文件失败"<<endl;
return0;
}
for(int i=0;i<10;i++)
{
out<<i;
}
cout<<endl;//endl就是回车
out.close();//关闭
return 0;
}Abrir con múltiples modos: (usando el operador OR: "|")
#include<fstream>
#include<iostream>
using namespace std;
int main()
{
fatream fp("test.txt",ios::in|ios::out);//对象命名为fp//同时以可读和可写入形式打开
if(!fp)
{
cerr<<"打开文件失败！"<<endl;
}
fp<<"I LOVE";//将这些字符"I LOVE"流进去fp
//上边的内容是把字符串流入了我们的文件中
//下边是通过str显示
static char str[10];//静态的数组，为了定义他不能够被改变。
fp.seekg(ios::beg);//ios::beg使得文件指针指向文件头；ios::end就是文件尾。
fp>>str;//把fp的内容给了数组
cout<<str<<endl;//把数组显示
fp.close();
return 0;
}
0x1 | 0x2 = 11 depende principalmente de si hay un número en este bit, si lo hay, será el modo correspondiente.