#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 码几个代码 。
六:类的封装性和信息的隐蔽
- 接口与实现的分离
- 通过成员函数对数据成员进行的操作称为类的 实现
- 当接口与实现(对数据的操作)分离时,只要类的接口没有改变,对私有实现的修改不会影响程序的其他部分。
- 类库有两种:一种是C++编译系统提供的标准类库,一种是用户根据自己的需要做成的用户类库,提供给自己和自己授权的人使用,这称为 自定义类库
- 类声明投喂年就成为用户使用类库的有效方法和公用接口。
- 类库的使用。像是使用零件一样方便的使用在时间中积累的通用的或专用的类,这就大大减少了程序设计的工作量,有效的提高了工作效率。
七:面向对象程序设计中的几个名词
方法:类中成员函数在面向对象程序理论中被称为
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个元素。
- 如果数组的个数非常少的话,可以直接定义初值,而不需要调用一个构造函数。
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)(参数列表) //定义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){}
&&在类体中声明了某一数据成员为场数据成员后,该类的所有对象中的该数据成员的值都是不能改变的,但不同对象中的该数据成员的值可以是不同的。&&
- 常成员函数
常成员函数,则只能引用本类中的数据成员,而不能修改他们,
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 对象的动态建立和释放
- 利用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指向的内存空间。
3.8 对象的赋值和复制
同类的不同对象之间赋值:
例如: Student stud1,stud2;
Stud1 = stud2; //将stud1各数据成员的值赋给stud2。。。。
注意:只对其中的数据成员赋值,而不对成员函数赋值,类的数据成员中不能包括动态分配的数据。
- 8.2 对象的复制
第一种:规则 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(); //定义静态成员函数
如果要是在类外调用数据成员函数,两种方式
- Box :: volume();
- 也允许通过对象名调用静态成员函数:
A.volume();
**静态成员函数主要是用访问静态数据成员,而不访问非静态成员,如果一定要引用本类的非静态成员,应该加对象名和成员运算符 “ . ”(a.width)