C++学习笔记

#include <iostream>    //代表输入输出流的意思  iostream

 

using namespace std;     using  namespace std ;

 

int main()

{

    cout << "Hello world!" << endl;

    return 0;

}

const   //定义常变量

 

 

const float PI=3.1415926

int  max(int x,int y

{

    int a ,b ;

 

}

#include<iostream>

 

using  namespace std;

 

int max(int a,int b)

{

    a>b?a:b     //三目运算符

}

函数模版化 % 针对不同类型的数据 进行相同的操作来进行

 

#include<stdio.h>

 

using namespace std;

 

template <typename T>    //模版声明，其中T为类型模版　

T max(T a,T b,T c)

{

    .......  // 一系列的中间处理过程，最后得出输出

}

 

如何调用这个模版

 

F    i= max(i1, i2, i3);

变量的引用

int a ;int &b=a ; //声明b是一个整型变量的引用变量不，它可以被初始化为a

引用中b的值变化a的值也跟着一起变化     地址和字节数的大小都是一样的

引用和指针的区别：

  如果前面有 类型说明符 则这个就是指的引用，否则就是指的指针

 

#include<iostream>

 

using namespace std;

 

void swap(int i,int j)

{

    int temp;

    if(i>j) temp =i;

    else  temp=j;

}

int main()

{

    int i=3,j=5;

    swap(i,j);

    cout << i << "," << j << endl;

    return 0;

}

 

内置函数：

inline int max(int i,int j.int k)

{

    if()

}     %  内置函数在调用的时候  就直接用就好了 ，不用在另外增加额外的说明

 

  ::   % 作用域运算符， 访问函数中的局部变量。

 

  1.3.10

 

字符串变量：

 string   string1 ，string2;

 string string11="China";

使用字符串变量的时候  要加头文件

#define<string>  %注意此处没有.h

也可以用 string 定义字符串数组，数组可以存储很多的信息

string name[5];

string name[5]={"Zhang","LI","FUN","Wang"，"Tian"};

 

 

new int(100) ;、     、    、

 

 

• 类的声明和对象的定义（笔记）

一．Struct student    结构体的声明

{  int num;

   Char  name;

   Char  sex;

};

Student stu1,stu2; // 定义了两个机构体变量stu1stu2

类的声明：(类中还可以定义操作语句，  void display()   )

Class student

｛  private：

     int num；

     Char  name;

     Char  sex;

   Public：

    Void  display()

{  cout << “num=” <<num << endl;

   Cout << “name=” << name<< endl;

   Cout << “sex=” << sex << endl ;  

// 以上四句语句是函数中的操作语句，

}    // 此处没有分号

｝；

Student  stu1， stu2；

 // 定义两个类的对象stu1和stu2 。

定义对象的时候有两种形式：

1：class student stu1 stu2；

2：student  stu1，stu2；

3 更简便的一种就是 不用出现类名，直接定义对象的名称

 

Struct定义的类 如果不加以说明 就当做是公有的，而class定义的类的  如果不加以说明  就全部当作是私有的，目的是为了兼容一切c代码。

 

二：类的成员函数

1，成员函数的性质：

2，在类外定义成员函数

Class student

｛ public：

      Void display；

   Private：

      Int  num；

      String  name；

      Char  sex；｝；

Void  student ：：display（） // :: 作用域限定符

  ｛ cout << “ ” <<  endl;

     Cout << “ ” <<  endl;

     Cout << “ ” <<  endl;

｝

Student  stu1,stu2;

3，inline成员函数

 类内的成员函数一般都被当作是内置函数来运行，这样可以减少运行的时间开销。在类内的话可以声明，也可以不声明。

Void display()

Inline void display() 将display函数显式的声明为内置函数。

如果函数不在类内的话，应当用inline作显式声明（在类内和类外都要做一次显式声明）

For example：

Class student

｛ public ：

     Inline  void display（）；

  Private：

Int num；

Char  name；｝；

Inine  void student：：display（）

4，成员函数的存储方式：
一个对象所占的空间大小只取决于该对象中数据成员所占的空间，而与成员函数无关。

四：对象成员的引用，

1，通过对象名和成员运算符访问对象中的成员

 Stu1.num =1

 // “.” 成员运算符，用来对成员进行限定，指明所访问的是哪一个对象中的成员。

// “。”只能访问类中的公有成员

2，通过指向对象的指针访问对象中的成员

For example、

 Class  Time

｛  public：

        Int  hour;

        Int   minute;

｝；

Time  t,*p;

P = &t;

Cout << p ->hour << endl ;

  ///   “-> “ 一定要注意这个标识符只能用于含有指针的情况下才能用。

P->hour   (*P).hour    t.hour    三者都是一样的

3，通过对象的引用来访问对象中的成员

   Time  t1;

   Time  &t2  = t1;

Cout  <<  t2.hour ;   

 //定义一个引用来调用time类中的hour 项，这种方法也是可以的

// 引用只是给对象换一个名称而已，都是对同一段存储空间的内容的调用。

五：  类和对象的简单应用举例

 Codeblocks 码几个代码 。

 

 

六：类的封装性和信息的隐蔽

1. 接口与实现的分离
2. 通过成员函数对数据成员进行的操作称为类的 实现
3. 当接口与实现（对数据的操作）分离时，只要类的接口没有改变，对私有实现的修改不会影响程序的其他部分。
4. 类库有两种：一种是C++编译系统提供的标准类库，一种是用户根据自己的需要做成的用户类库，提供给自己和自己授权的人使用，这称为 自定义类库
5. 类声明投喂年就成为用户使用类库的有效方法和公用接口。
6. 类库的使用。像是使用零件一样方便的使用在时间中积累的通用的或专用的类，这就大大减少了程序设计的工作量，有效的提高了工作效率。

 

七：面向对象程序设计中的几个名词

方法：类中成员函数在面向对象程序理论中被称为

Stu.display()   合在一起叫做消息。

 Stu:是对象，display（）是方法。

 

 

第三章 关于类和对象的进一步讨论

 

一，构造函数

1，对象的初始化：

   a，类的数据成员是不能在声明类时初始化的，

   B，如果一个类中所有的成员都是公用的，则可以在定义对象时对数据成员进行初始化：

  Class time

｛ public：
      int  hour；

      Int  minute；

      Int  sec；    

｝；

Time  t1={14,24,55} ; // 将t1初始化为14 ，24， 55

 //如果成员是私有的 则不能用这种方法来做。

 

2，构造函数的作用

通过构造函数来处理对象的初始化：

构造函数是一种特殊的成员函数，与其他成员函数不同，不需要用户来调用它，而是在建立对象时自动执行。

构造函数的要求： 构造函数的名称必须与类名同名，而不能用户随意起

构造函数可以直接在类内定义，也可以在类外定义。

构造函数没有 void 这个前缀。

构造函数是系统自己执行，而且只执行一次。

3，带参数的构造函数

采用 带参数的构造函数，在调用不同对象的构造函数时，从外面将不同的数据传递给构造函数，以实现不同的初始化，构造函数首部的一般格式为：

四，

用参数 “初始化表”对数据成员初始化

Box :: box(int h,int w,int len):height(h),width(w),length(len){12,23,34}

 

重复一边：

Box :: box(int h,int w,int len) : height(h),width(w),length(len) {12,23,45}

  /// 这个是 参数初始化表 的方法。

 

五，构造函数的重载

一个类中可以有很多个构造函数，以便对类对象提供不同的初始化方法，供用户选用。这些构造函数具有相同的名字，而参数的个数和参数的类型不相同。这称为函数的 重载

根据实际需要，可以写出多个构造函数，在实际运用中，根据实际需要调用哪一个构造函数，但是只有一个默认的构造函数，默认的构造函数是唯一的。

尽管在一个类中可以包含多个构造函数，但是对于每一个对象来说，建立对象时只执行一个构造函数，并非每个构造函数都被执行。

 

六，使用默认参数的构造函数

参数构造表的应用十分重要，一定要熟练的掌握，简单方便。

Box ：： box（int h,int w,int len）:height(h),width(w),length(len) { }

参数构造表的应用十分重要。

 

一般不应同时使用构造函数的重载和有默认参数的构造函数。

 

3.2 析构函数

 这部分到以后用到时候在自己做总结把！

 

3.4 对象数组

1例如： student  stud[50];//假设已经声明了student类，定义stud数组，有50个元素。

1. 如果数组的个数非常少的话，可以直接定义初值，而不需要调用一个构造函数。

   Student stud[3]={60,70,80}; //3个实参分辨传递给三个数组元素的构造函数。

Student stud[3]

{

Student(110110,18,98);

Student(1131021,15,49);

。。。。

}  // 以上就是对象数组的应用，还应该在加强应用。

 

3.5 对象指针

 指针可以用来指向一般的变量，也可以指向对象。

3.5.1指向对象都额指针

对象空间的起始地址就是对象的指针

Class time

{

Public:
int hour;

Int minute;

Int sec;

Void get_time();

};

Void Time::get_time()

{

Cout << hour <<”:”<<minute<<”:”<<sec<<endl;

Time *pt;}

要点： 类名 *对象指针名

当遇到有指针的时候，一定要注意这个符号的用法 —>   相当于一点。

3.5.2 指向对象成员的指针

1，指向对象数据成员的指针

P1 = &t1.hour; cout << *p1 <<endl; //输出t1.hour的值。

2，指向对象成员函数的指针

 指向普通函数的指针变量的定义方法：

Void (*p)(参数列表)  // 其实就是相当于把函数定义的名称换成 *p   和函数定义的前后是一样的

定义一个指向对象成员函数的指针变量

Void(Time :: *p2)(参数列表)　　//定义ｐ２为指向time类中公用成员函数的指针变量。

指向一个公用成员函数的指针变量

p2 = &Time :: get_time;

  //一定要注意指针的运用是　先定义然后在指向哪一个具体变量。

 

3.5.3  this指针

在每个成员函数中都包含一个特殊的指针，这个指针的名字是固定的，成为 this指针。

（着重在与理解上，理解c++编译的过程）

3.6  共用数据的保护

既要使数据能在一定范围内共享，又要保证它不被任意修改，这时可以使用const，即 把有关的数据定义为常量。

3.6.1 常对象

 Time const t1(12,24,46); //常对象中的数据成员为常变量且必须要有初值，这样，在所有的场合下，对象t1中的所有数据成员的值都不能被修改，凡希望保证数据成员不被修改的对象，可以声明为常对象。

也可以这样写   const Time t1(12,24,46); 

 **声明，常对象不能调用该对象的非const型的成员函数。

只需要将该成员函数声明为const

   Void get_time() const;  //将函数声明为const，表示get_time()是一个常成员函数，常成员函数可以访问常对象中的数据成员，但仍然不允许修改常对象中数据成员的值。

3.6.2  常对象成员

 （1）常数据成员

 Const int hour;  //只能用过构造函数的参数初始化表对场数据成员进行初始化，

如果在类外定义构造函数，应写成以下形式：

Time :: Time(int h):hour(h){}

&&在类体中声明了某一数据成员为场数据成员后，该类的所有对象中的该数据成员的值都是不能改变的，但不同对象中的该数据成员的值可以是不同的。&&

1. 常成员函数

常成员函数，则只能引用本类中的数据成员，而不能修改他们，

Void get_time() const // 注意const的位置在后面。

 

3.6.3指向对象的常指针

Time t1(10,12,15),t2;

Time *const ptrl = &t1; //const位置在指针变量名前面，规定ptrl的值是常值。

Const char  c[ ]=”boy”;

Const char  *pl;

Pl = c ;//pl指向常变量（char数组的首元素）

//如果一个变量已被声明为常变量，只能用指向常变量的指针变量指向它

****** 此部分以后用到的时候在自己练一下把！

 

3.6.6 const型数据的小结

 

3.7 对象的动态建立和释放

1. 利用new来开辟新的存储空间：需要先定义一个指向该类的对象的指针变量

例如：

   Box 　*pt;//定义一个指向box类对象的指针变量

   Pt = new Box; //在pt中存放了新建对象的起始地址。

在程序中就可以通过pt访问这个新建对象，

Cout << pt－>height;

Cout << pt ->volume(); //调用该对象的volume函数；

***还能在执行new时对新建立的对象进行初始化：

　Box  *pt = new Box(12,15,18) // 重点句式

再不需要使用由new建立的对象时，用delet删除：

　Delet pt;//释放pt指向的内存空间。

 

３.８　对象的赋值和复制

同类的不同对象之间赋值：

例如：　Student stud1,stud2;

        Stud1 = stud2; //将stud1各数据成员的值赋给stud2。。。。

注意：只对其中的数据成员赋值，而不对成员函数赋值，类的数据成员中不能包括动态分配的数据。

• ８.２　对象的复制

　第一种：规则　Box　box2(box1);//用已有的对象box1去克隆一个新对象box2;

　第二种：Box box2 =box1;

可以在一个语句中进行多个对象的复制

Box　box2 =box1,box3 = box2;

 

3.9静态成员

3.9.1 静态数据成员

 静态数据成员是一中特殊的数据成员，以关键字static开头；

例如：class Box

{ public:
       int volume();

  private:

  Static int height;  //把height定义为静态的数据成员

  Int  width;

  Int  length;

};

注意：静态成员不随对象的建立而分配空间，也不随对象的撤销而释放。。静态数据成员是在程序编译时被分配空间的，到程序结束时才释放空间。静态数据成员可以初始化，但只能在类体外进行初始化。其一般形式： 数据类型  类名 ：：静态数据成员名 = 初值

   Int Box :: height = 0;   （不必在初始化语句中添加 static ）

***如果未对静态数据成员赋初值，自动赋0；

3.9.2 静态成员函数

 Static int volume(); //定义静态成员函数

 如果要是在类外调用数据成员函数,两种方式

1. Box ：： volume();
2. 也允许通过对象名调用静态成员函数：

   A.volume();

**静态成员函数主要是用访问静态数据成员，而不访问非静态成员，如果一定要引用本类的非静态成员，应该加对象名和成员运算符 “ . ”(a.width)