C++：随笔1

面向对象（oo）:对象最终分为两个要素：属性（是表明了你这个类的特征，类中的变量）和行为（是你生成的这个对象他的一个动作，类中的方法）。

1封装：意味着把对象的属性和方法结合成一个独立的系统单位，并尽可能隐藏对象的内部细节。

2抽象：抽象的过程是对具体问题概括的过程，是对一类公共问题进行统一描述的过程

3继承：子类对象拥有与其基类相同的全部属性和方法。

4多态：是指在基类中定义的属性和行为被子类继承后，可以具有不同的数据类型或者表现行为等特性。（在相同的同时可以发展你的特性）

动物这个基类，它的子类就会有老虎，兔子等。作为动物有一个行为定义为Move()，那么这些子类继承下来后会根据自己的特性采取不同个性的Move()方式（走跑飞等不同的Move）。

数组求和C语言方案：

由于数组名是他的第一个元素的地址，所以数组和指针他们有一些相关性，但他们又不是完全等同，

#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;
}

更改一下：

#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;
}

得出结论：将函数的参数声明为数组和声明为指针是一样的。

C语言中使用printf实现输出，但是printf是一个函数，

而上述C++中使用的是cout输出，而cout是一个对象。cout是一个输出流对象，他是console out(控制台输出)的缩写，是属于basic_ostream类的对象，ostream类在iostream头文件中定义。（类就是一类事物的抽象集合在一起就是一个类，比如人是一个类，亚洲人是一个类的继承，中国人是一个小类。）

流对象cin，这个对象的类型是istream，他知道如何从用户终端读取数据。

cin>>i;//cin，操作符又称为提取操作符，它依次从输入流对象cin提取一个整数。（遇见空格或者Enter键就说是一个整数。）

当用户进行键盘输入时，对应的字符将输入到操作系统的键盘缓冲区中，这样当用户点击键盘上的Enter键时，操作系统把键盘缓冲区的内容传输到cin流的内部缓冲区（就是stdin这个流缓冲区），“>>”操作符随后从这缓冲区提取需要的信息。

using namespace std;//名称空间。C++标准库所使用的所有标识符（类，函数，对象等的名称都是在一个同一个特殊的名称空间（std中来定义））（一切变量都包含在这个名称空间里面，要引用这个空间里的变量，必须要把这个空间给套出来）（如果没有这条指令，我们可以使用std::cout这样的语法来调用输出流对象）

PS：重载就是赋予一个旧事物新的意义。“>>”最初定义为右移操作符，它在C++中进行了重载，当它按照这里所示的方式使用时，他就用于从输入流对象提取信息。

C语言和C++一样，字符串是以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();

--------文件的I/O：

编写一个文件复制程序，将一个文件复制到另外一个文件。*（例如：fileCopy，sourceFile，destFile）(意思就是有一个fileCopy.exe程序，将source.c拷贝到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;

}

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;
}

C语言是用了一个指针FILF*类型指针就可以直接指向我们这个内存中的文件的一个地址，C++中通过一个类通过一个对象，这个对象还是专门拿来输入的，再来通过这个对象的访问它的成员函数访问来对这个文件进行操作。

文件的读取类：ifstream。

文件的写入类：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;
}

以上代码在创建一个ifstream和ofstream类的对象时，将文件的名字传递给他们的构造函数（暂时理解为对象默认使用的函数（方法））。

上述还可以接受两个参数：

ifstream in(char* filename,int open_mode);
//第一个是指针指向了文件名（他是一个字符串）
//open_mode表示打开模式，气质用来定义怎么的反射光hi打开文件（跟open的参数一样）
模式见下图
（什么是文本形式，什么是二进制形式？没有翻译为一堆数据那他就是文本形式）

图：

例子：

#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;
}

以多种模式并存的方式打开：（使用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主要看这个位有没有数字，如果有他就实现该为对应的模式。

猜你喜欢