码迷,mamicode.com
首页 > 编程语言 > 详细

大学C++程序设计教程期末复习重点

时间:2018-06-25 15:11:47      阅读:166      评论:0      收藏:0      [点我收藏+]

标签:用处   strcmp   级别   classname   virt   析构函数   p12   als   ase   

第一章

1.cin与count的应用<iostream>

例:

cin>>a;
cout<<"hello"<<endl;
cout<<he<<15<<endl;
cout.wtdth(10);//cout.fill("*");

调整字段宽度的函数int width():

a、控制符int width()将用来调整字段的宽度,因为width是成员函数,所以要通过对象来调用,比如cout.width()将显示当前的字段宽度,默认为0,而cout.width(3)将把字段宽度设定为3。
注意C容纳字段的方式为给字段分配刚好合适的宽度来容纳字段,所以C中默认的字段宽度为0,以适合于所有的字段。
b、width的默认对齐方式为右对齐,即如果cout.width(12)如果字段没有这么宽,则将在字段的左边填以空格来达到12个字段的宽度。
c、还要注意的是width只影响他设置后的下一个输出,再下一个字段输出后,后继的字段被恢复为默认值,比如cout.width(12); cout<<2<<3;则输出2时会以12字段的宽度显示,但显示3时就会以默认的方式显示了。
d、int width()调用他时将会反回上一次的字段宽度的值。
填充字符:成员函数fill()可以用来改变填充的字符,比如cout.fill(‘’),使用填充空白部分。fill函数在设置后将一直有效,除非被重新设定。
cout<<setfill("*")<<20<<endl;

setw设置输出长度,setfill设置如果输出的整型不够长用什么填充

2.注释:

2.1

/* 这是注释 */
/* C++ 注释也可以
* 跨行
*/

2.2 //

3.main函数

main函数是C程序的入口函数,C标准要求main()函数的返回值类型为int。

3.1.函数内并可以不出现return语句

当main()函数的返回值为int,而函数内并没有出现return语句时,同样可以通过编译并正常运行。这是因为编译器在main()函数的末尾自动添加了return 0;的语句。所以,main()函数是C++程序经过特殊处理的函数。其他的返回值类型不是void的函数,如果没有使用return语句,编译器将报错。

3.2.main()函数被称为“入口函数”,那main()函数一定是程序中的第一个被执行的函数吗?

考察如下程序。

#include <iostream>
using namespace std;
class A{
public:
    A(){
        cout<<"In default A constructor"<<endl;
    }
};
A b;
int main()
{
    cout<<"In main()"<<endl;
    return 0;
}

编译运行以上代码输出:

技术分享图片

在这个程序中,先输出的“In default constructor”,然后输出的是“In main()”。可见,对象a的构造函数是先于main()函数执行的。实际上,所有的外部对象的构造函数都是先于main()函数执行的。如果要对类中的成员对象进行初始化,那么这些对象的构造函数也是在main()函数之前执行的。如果在这些构造函数中还调用了其他函数的话,就可以是更多的函数先于main()函数之前运行。因此main()函数不一定是C++程序的第一个被执行的函数。

3.3.main()函数可以带参数

main()函数带参数是用来提供用户向程序输入参数。main()所带的参数有固定格式,即int main(int argc,char* argv[]),其中argc代表参数的个数,argv数组中的每一个元素则保存命令行参数内容的字符串。考察如下程序。

#include <iostream>
using namespace std;

int main(int argc,char* argv[])
{
    if(argc>1)
    cout<<"Hello "<<argv[1]<<endl;
    return 0;
}

假设此程序经过编译之后生成的main.exe,那么在控制台输入”main.exe LVLV”,会输出“Hello LVLV”。使用命令行参数时注意以下几个问题。
(1)命令行输入的程序名称为程序的第一个参数,以上程序中argv[0]保存的是main.exe,尽管输入的只有一个参数”LVLV”,但是参数数量argc包含了程序名称,因此argc等于2。在其他编程语言(如C#)中,命令行参数并不包含执行文件的名字。

(2)在命令行中,空格被认为是命令行参数的分割符。也就是说,也就是说同一个参数内部不允许出现空格。如果在一个参数中出现空格,可以使用双引号括起来。如输入main.exe “LVLV and JF”。

4.标识符的命名规则

*一个合法的标识符只能由数字、字母、下划线、美元符号$组成,不能含有其他符号(不能有空格)
*不能以数字开头
*严格区分大小写
*关键字不能做标识符

第二章

1.C++数据类型

1.1基本类型(Byte ,short ,int ,long ,double float ,char ,Boolean)
整型:短整型,整型,长整型
字符型:
布尔型:
实型:浮点型,精度型
1.2指针
1.3构造类型
数组
枚举型
结构体
共用体

2.bool

*只有 true,false
在底层储存的时候Boolean类型占据一个字节,因为实际存储的时候FALSE的底层是0,true底层是1.
布尔类型在实际开发当中非常重要,经常使用在逻辑运算和条件控制语句中。
实际上,所有非0的整数值都被编译系统认为是true

Boolean A= false; if(A) { }

3.变量的初始化:

int a=3;
int a(3);

4.++ --

"++""--"都为单目运算符
作为运算符来说"++""--"的优先级较高,高于所有算数运算符和逻辑运算符,但是使用这两个运算符时要注意它们的运算对象只能是变量,不能是其他表达式
例:(i+j)++就是一个错误的表达式

5.const

const <类型说明符><常量名>=<常量值>
const int maix=255;
注意:使用const修饰的变量实际上是常量,不能被程序改变,因此在声明时一定要进行初始化赋值。常量变量一经生成,其值不能改变,如果在以后的执行语句对常量变量进行赋值就会导致编译错误!!!!!
const还可以用于修饰函数的参数,同样也不允许出现对它们的赋值操作

6./是除,%整除取余


第三章

1.C++的控制结构p47

1.1顺序结构
1.2选择结构

if switch

1.3循环结构

for while do..while

2.p68

a.编写计算n!的程序

#include<iostream>
using namespace std;
int main()
{   
    int n,i,m;
    cin>>n;
	for(i=1;i<=n;i++)
	m=m*i;
	cout<<m<<endl;
	return 0;
}

b.求1+2+3+4······+99+100的和

#include<iostream>
using namespace std;
int main()
{
    int s=0,t=1;
	int n;
	for(n=1;n<=100;n++)
	{
		t=t+n;
		s=s+t;
	}
cout<<"1到100的累加和为:"<<t<<endl;
return 0; 
}

第四章

1.数组的定义

1.1下标从0开始

int a[2][3];
例如,要声明一个类型为 double 的包含 10 个元素的数组 balance,声明语句如下:
double balance[10];

1.2初始化数组

在 C++ 中,您可以逐个初始化数组,也可以使用一个初始化语句,如下所示:
double balance[5] = {1000.0, 2.0, 3.4, 7.0, 50.0};
大括号 { } 之间的值的数目不能大于我们在数组声明时在方括号 [ ] 中指定的元素数目。
如果您省略掉了数组的大小,数组的大小则为初始化时元素的个数。因此,如果:
double balance[] = {1000.0, 2.0, 3.4, 7.0, 50.0};
您将创建一个数组,它与前一个实例中所创建的数组是完全相同的。下面是一个为数组中某个元素赋值的实例:
balance[4] = 50.0;
上述的语句把数组中第五个元素的值赋为 50.0。所有的数组都是以 0 作为它们第一个元素的索引,也被称为基索引,数组的最后一个索引是数组的总大小减去 1。
以下是上面所讨论的数组的的图形表示:

技术分享图片

2.P76 字符串处理库函数<cstring>

1* strcpy(s1, s2);

复制字符串 s2 到字符串 s1。

2* strcat(s1, s2);

连接字符串 s2 到字符串 s1 的末尾。

3* strlen(s1);

返回字符串 s1 的长度。

4 strcmp(s1, s2);

如果 s1 和 s2 是相同的,则返回 0;如果 s1<s2 则返回值小于 0;如果 s1>s2 则返回值大于 0。

5 strchr(s1, ch);

返回一个指针,指向字符串 s1 中字符 ch 的第一次出现的位置。

6 strstr(s1, s2);

返回一个指针,指向字符串 s1 中字符串 s2 的第一次出现的位置。

eg:


#include <iostream>
#include <cstring>
 
using namespace std;
 
int main ()
{
   char str1[11] = "Hello";
   char str2[11] = "World";
   char str3[11];
   int  len ;
 
   // 复制 str1 到 str3
   strcpy( str3, str1);
   cout << "strcpy( str3, str1) : " << str3 << endl;
 
   // 连接 str1 和 str2
   strcat( str1, str2);
   cout << "strcat( str1, str2): " << str1 << endl;
 
   // 连接后,str1 的总长度
   len = strlen(str1);
   cout << "strlen(str1) : " << len << endl;
 
   return 0;
}

编译执行后结果:

strcpy( str3, str1) : Hello
strcat( str1, str2): HelloWorld
strlen(str1) : 10

3.编程实现两个字符串的连接(数组,类string)

#include <iostream>
#include <string>
using namespace std;
int main()
{
char *cat(char *a,char *b);
char s1[50] = "please ",*s2 = "let me in.";
puts(cat(s1,s2));
return 0;
}
char *cat(char *a,char *b) 
{
    char *p = a,*q = b; 
    while(*p++);
      p--;
    while(*p++ = *q++);
     *p = ‘\0‘;
    return a; 
}

第五章*

1.函数的定义

函数必须先定义后才能使用
<函数值类型> 函数名(<形式参数表>)

2.函数的参数传递

2.1传值

2.1.1传地址值(指针)

该方法把参数的引用复制给形式参数。在函数内,该引用用于访问调用中要用到的实际参数。这意味着,修改形式参数会影响实际参数。

2.1.2传变量值
该方法把参数的实际值复制给函数的形式参数。在这种情况下,修改函数内的形式参数对实际参数没有影响。

2.2传引用[P97例5-4]

该方法把参数的引用(小名)复制给形式参数。在函数内,该引用用于访问调用中要用到的实际参数。这意味着,修改形式参数会影响实际参数。 [P97例5-4]利用引用编写交换函数swap() 程序代码如下:

#include<iostream>
using namespace std;
void swap(int &x,int&y)
{
    int tmp=x;
    x=y;
    y=tmp;
}
int main()
{
    int a=2,b=3;
    cout<<"Before exchange:a="<<a<<",b="<<b<<endl;
    swap(a,b);
    cout<<"After exchange:a="<<a<<",b="<<b<<endl;
    return 0;
   
}

编译执行后结果:

Before exchange:a=2,b=3
After exchange:a=3,b=2

3.P102 带有默认参数的函数的声明

(1)所有的默认参数均需放在参数表的最后

eg:

void func(int x,int n1=1,int n2=2);

若使用func(5,4);的方式调用该函数,则X的值为5,n1的值为4,n2的值为2。

(2)默认参数的声明必须出现在函数调用前

第六章

1.*与& p119【再看看书上】

1.1“&”称为取地址运算符

返回变量的地址。例如 &a; 将给出变量的实际地址。

1.2“*”称为指针运算符(取内容运算符)

指向一个变量。例如,*var; 将指向变量 var。

2*. new与delete 学会灵活运用p125

2.1new
<指针> = new <类型>
<指针> = new <类型>(<初值>);
2.2delete
delete <指针>
3.数组
new运算符也可以为数组申请内存,其用法如下:
<指针> = new <类型> [<元素数>];
若释放数组的空间,必须放一个空的方括号“[]”在操作符delete和指向该类对象数组的指针之间

eg;

int *p =new int[size];
delete []p;

第七章

1.函数重载的特点P145

a.通过重载,可以将语义、功能相似的几个函数用同一个名字表示,这样便于记忆,且提高了函数的易用性;
b.面向对象理论中的类的构造函数需要重载机制。因为构造函数与类名相同,所以如果想用几种不同的方法创建对象,其对应的构造函数缺被限制只有一个名字,这时只能靠重载来实现,所以累可以有多个重名的构造函数

2.内联函数p150

将函数体的代码直接插入到函数调用处来节省调用函数的时间开销【用空间换时间】
被频繁调用,语句少,无循环语句
2.1关键字 inline
2.2注意事项 p151
(1)在C++程序中,除了在函数体中含有循环、switch分支和复杂的嵌套的if语句的函数外,所有函数均可被说明为内联函数

【内联函数不包含循环语句】

(2)内联函数大多都是小函数,其函数体不宜过大,一般宜在1到5行之间。
(3)关键字inline与函数定义放在一起才能使函数成为内联,内联函数的定义必须出现在对该函数的调用之前。这是因为编译器在对函数调用语句进行代换时,必须事先知道代换该语句的代码是什么。不然即使在函数的声明和函数的定义处均加上关键字inline都不行。
(4)由于计算机的资源有限,使用内联函数虽然节省了程序运行的时间开销,但却增大了代码占用内存的空间开销。因此具体编程时,应仔细的权衡时间开销与空间开销之间的矛盾,以确定是否采用内联函数。

第九章

1.面向对象的4个特征

抽象,封装,继承,多态

2.类的声明【声明时不能初始化】

class
{
   ······
   y;
}

3.类的成员有数据成员 和成员函数 ++ ;访问权限有私有(private),公有(public), 保护(protected)

4.成员函数在类外如何定义(作用域)

<类型><类名>::<函数名>(<参数表>) {<函数体>}

5*.定义一个Dog类,包含name,age,sex,weight等属性以及对这些属性的操作方法。实现并测试这个类。P210 习题1


#include <iostream>
#include <cstring>
using namespace std;
class Dog
{
    char name[20];
    char sex;
    int age;
    float weight;
public:
    void Register(char * Name,int Age,char Sex,float Weight);
    char * GetName()
    {
       return name;
        
    }
    int GetAge()
    {
    return age;
    
    }
   char GetSex()
   {
   return sex;
    
   }
   float GetWeight()
   {
   return weight;
       
   }
   void Speak()
   {
   cout<<"Arf!Arf!"<<endl;}
   };
   void Dog::Register(char * Name,int Age,char Sex,float Weight)
  {
  strcpy(name,Name);
  age=Age;
  sex=Sex;
  weight=Weight;
  }
int main()
{
  char name[20];
  char sex;
  int age;
  float weight;
  Dog dog1;
  cin>>name>>age>>sex>>weight;
  dog1.Register(name,age,sex,weight);
  cout<<"Dog ’ s name:"<<dog1.GetName() <<endl;
  cout<<"Dog ’ s age:"<<dog1.GetAge()<<endl;
  cout<<"Dog ’ s sex:"<<dog1.GetSex()<<endl;
  cout<<"Dog ’ s weight:"<<dog1.GetWeight()<<endl;
  cout<<"Dog speak:";
  dog1.Speak();
  return 0;
  }

第十章

1*.构造函数的定义

类的一个特殊的成员函数,用来处理对象的初始化,每次生成类对象(实例化)时自动被调用
格式:<类名>(<参数表>);

2*.构造函数的特点

2.1构造函数与类同名,且没有返回值类型 2.2构造函数既可以在类外定义,也可以作为内联函数在类内定义 2.3构造函数允许重载

3.拷贝构造函数 p217

构造函数的形参还可以是本类的对象的引用,其作用是用一个已经存在的对象去初始化一个新的同类对象,也称为拷贝构造函数 格式

classname (const classname &obj) {
   // 构造函数的主体
}

4.析构函数的定义及特点

4.1作用:对象消亡时,自动被调用,用来释放对象占用的空间【先析构再delete】
4.2特点:
(1) 析构函数的名字与类名相同,只需在前面需要加上波浪号"~"以与构造函数分开
(2) 构造函数不带有任何参数,因此不能重载
(3) 无析构函数没有返回值
(4) 一个类最多只有一个析构函数

5*.p236 习题1

#include<iostream>

#include<string>

using namespace std;

class Dog

{

string name;

char sex;

int age,weight;

public:

Dog():name("dog2"),sex(‘f‘),age(2),weight(50) {} // 无参数初始化表

Dog(string Name,char Sex=‘m‘,int Age=3,int Weight=40); //带默认值的构造



void print();

};

Dog::Dog(string Name,char Sex,int Age,int Weight):name(Name),sex(Sex),age(Age),weight(Weight)

{
    
}

void Dog::print()//输出信息

{

cout<<"name is:"<<name<<endl;

cout<<"sex is:"<<sex<<endl;

cout<<"age is:"<<age<<endl;

cout<<"weight is:"<<weight<<endl;

}

int main()

{

string N="dog1";
char S;

int A,W;

/**************************************

有默认参数的构造函数

**************************************/ cout<<"使用有默认值的初始化:"<<endl;

cout<<"没有输入前的默认参数为:"<<endl;

Dog dog1(N);

dog1.print();

//输入数据

cout<<"输入狗名,年龄,性别,体重"<<endl;

cin>>N>>A>>S>>W;

Dog dog(N,S,A,W);

cout<<"输入数据后:"<<endl;

dog.print();

/********************************************** 使用初始化表

**********************************************/ Dog dog2;

cout<<"调用系统无参数初始化表:"<<endl;

dog2.print();


return 0;

}

第十一章

1.派生类的声明 P239

声明格式:

class 派生类名:继承方式 基类名1,继承方式 基类名2
{
    新增加的成员声明;
}

2.继承方式公有继承(public)私有继承(private),++保护继承(protected)++p239

3.公有继承 p249 表11-1

public(公用的):既可以被本类中的成员函数所引用,也可以被类的作用域内的其他函数(即类外)引用。【在派生类内和外部都可以访问】

private(私有的):只能被本类中的成员函数引用,类外不能调用(友元类除外)

protected(受保护的):不能被类外访问,但可以在派生类的成员函数访问。

可以这么简单的认为:

1、凡是基类中私有的,派生类都不可访问。

2、基类中除了私有的成员,在派生类中的访问属性总是 以安全性高{ 继承方式,基类的访问属性 } 的方式呈现。(安全性级别:私有>保护>公有)

4.

派生类构造函数执行的顺序
(1)调用基类构造函数,调用顺序按照它们被继承时声明的基类名顺序执行。
(2)调用内嵌对象构造函数,调用次序按各个对象在派生类内声明的顺序
(3)执行派生类构造函数体中的内容
派生类析构函数执行的顺序【与构造函数相反】
(1)执行派生类析构函数
(2)执行内嵌对象的析构函数
(3)执行基类的析构函数

p250 参考例11-3

#include<iostream>
#include<cstring>
using namespace std;
class Person
{
    cahr Name[10];             //姓名
    int Agepublic:
    Person(char*name,int age)
    {
        strcpy(Name,name);
        Age=age;
        cout<<"constructor of person"<<Name<<endl;
        
    }
    ~Person()
    {
         cout<<"deconstructor of person"<<Name<<endl; 
    };

    class Student:public Person
    {
        char ClassName[10]//班级
        Person Monitor;  //班长   内嵌对象
    public:
    Student(char*name,int age,char *classname,char *name1,int age1):Person(name,age),Monitor(name1,age1)
    {
          strcpy(ClassName,classname);
          cout<<"constructor of Student"<<endl;
 
    }
    ~Student()
    {
        cout<<"deconstructor of Student"<<endl;
    }
};
    int main()
    {
        Student stu("张弓长"18"计算机51""李木子"20)return 0;
    }

5.编程题:由一个圆类派生圆柱类,圆由半径,构造函数,面积函数圆柱由高,构造函数,体积函数

#include<iostream>
#include<cmath>
using namespace std;
const double PI=3.1415926;
class Circle
{
protected:
    double c_r;
public:
    Circle(double r)
    {
        c_r=r;
    }
};
 
class Circular:public Circle
{
    double c_h;
public:
    Circular(double r,double h):Circle(r)
    {
        c_h=h;
    }
    double GetCircular_t()
    {
        return PI*c_r*c_r*c_h;
    }
	 double GetCircular_b()
    {
        return (2*PI*c_r*c_h)+(2*PI*c_r*c_r);
    }
    void ShowCircular()
    {
        cout<<"圆柱体的体积 ="<<GetCircular_t()<<endl;
		 cout<<"圆柱体的表面积 ="<<GetCircular_b()<<endl;
    }
};
 
int main()
{
    Circular b(10,10);
    b.ShowCircular();
    return 0;
}

第十二章

1.多态性的两种不同形式:编译时多态性运行时多态性P265

2.虚函数

关键字 virtual 格式:

virtual 函数返回类型 函数名() {函数体}

定义p269

实现多态性,通过指向派生类的基类指针或引用,访问派生类中同名覆盖成员函数

3.

3.1纯虚函数的定义

基类中的虚函数是为了派生类中的使用而声明定义的,其在基类中没有任何意义。此类函数我们叫做纯虚函数,不需要写成空函数的形式,只需要声明成:
virtual 函数类型 函数名(形参表列)=0;
注意:纯虚函数没有函数体;
最后面的“=0“并不代表函数返回值为0,只是形式上的作用,告诉编译系统”这是纯虚函数”;
这是一个声明语句,最后应有分号。
纯虚函数只有函数的名字但不具备函数的功能,不能被调用。在派生类中对此函数提供定义后,才能具备函数的功能,可以被调用。

3.2 抽象类的概念p272

在面向对象的编程过程中,有些类的创建是毫无意义的,它的概念是抽象的,比如动物,电器,人这样类,比如到商店给店员说我要买一台电器。编程过程中可以将这些类设置为抽象类,以防止它们创建对象。
只要一个类中出现纯虚函数,那么这个类就是抽象类。
Class Animal{

         Public:

virtual void show() = 0;//纯虚函数的表达

};
抽象类除了不能实例化之外,和其他类没有任何区别。

4.

C++提供的两种重载方式为函数重载和运算符重载

不适合重载的运算符是那五个p275

. (成员访问运算符)
.* (成员指针访问运算符)
:: (域运算符)
sizeof (长度运算符)
?: (条件运算符)

5.常成员函数p277

用const修饰的声明声明成员函数称为常成员函数
声明:<类型标志符>函数名(参数表)const;
说明:
1. const是函数类型的一部分,在实现部分也要带该关键字。

2. const关键字可以用于对重载函数的区分。

3. 常成员函数不能更新任何数据成员,也不能调用该类中没有用const修饰的成员函数,只能调用常成员函数和常数据成员。

第十三章

1.函数模板的定义及使用p291 函数模板:是一种抽象通用的函数,用它可生成一批具体的函数。这些由函数模板实例化生成的具体函数称为模板函数。

template<typename T>
<类型><函数名>(<参数表>)
{
···
    }

2.友元函数p297

2.1定义
类的友元函数是定义在类外部,但有权访问类的所有私有(private)成员和保护(protected)成员。尽管友元函数的原型有在类的定义中出现过,但是友元函数并不是成员函数。
友元可以是一个函数,该函数被称为友元函数;友元也可以是一个类,该类被称为友元类,在这种情况下,整个类及其所有成员都是友元。

2.2关键字 friend

使用友元函数声明的一般形式:
friend <返回类型> <函数名> (<参数列表>);

2.3使用友元函数注意的要点:
  1. 类中通过使用关键字friend 来修饰友元函数,但该函数并不是类的成员函数,其声明可以放在类的私有部分,也可放在共有部分。友元函数的定义在类体外实现,不需要加类限定。
  2. 一个类中的成员函数可以是另外一个类的友元函数,而且一个函数可以是多个类友元函数。
  3. 友元函数可以访问类中的私有成员和其他数据,但是访问不可直接使用数据成员,需要通过对对象进行引用。
  4. 友元函数在调用上同一般函数一样,不必通过对对象进行引用。

大学C++程序设计教程期末复习重点

标签:用处   strcmp   级别   classname   virt   析构函数   p12   als   ase   

原文地址:https://www.cnblogs.com/clzhao18-625/p/9223805.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!