标签：
回顾：
1.第一个C++程序
头文件
输入输出
名字空间 using namespace std;
扩展名
编译方式 g++
2.名字空间
3.结构、联合、枚举
4.字符串
标准库提供的表示字符串的类型string
5.bool
1 0
6.函数升级
函数重载
相同的作用域，函数名相同，但是参数表不一样
默认参数
1.默认参数一定要靠右
2.避免二义性
3.默认参数要写在声明中
7.动态内存分配
new/delete
1.按类型分配空间
2.在分配空间的同时就可以初始化
delete []p;
-----------------------------------------
1.引用
引用即别名
引用是一个已经定义了的变量的别名。
int a = 10;
int& ra = a;
声明一个引用的格式：
类型& 引用名=已定义的变量;
&:引用声明符，不是取地址
1.一个变量的引用，和它本身是同一个东西，只要改变一个，另一个也随之改变
2.引用最主要的用途是用来作函数参数
swap(a,b); a1 = a,b1 = b;
swap3(a,b); int &a1 = a,int &b1 = b ;
1.节省空间
2.提高效率
3.引用作来返回值
2.类和对象
现实世界： 类
哈士奇
电脑
...
类：是一组具有相同属性和行为的对象的抽象和描述。
抽象：将有关事物的共性归纳、集中的过程。
对象:
万物皆对象。object
在面向对象程序设计中：
类：将多个对象的共性提取出来，定义的一种新的数据类型
是对 对象的属性和行为的抽象和描述。
对象：类 类型的变量
int a ;
类和对象的关系：
类它是抽象的，不占用空间
对象是具体的，占存储空间
类是对象的抽象，对象是类的具体的实例
在面向对象程序设计，总是先声明类，然后再由类生成其对象。
学生：
struct student
{
int num;
string name;
int age;
};
class student
{
int num;
string name;
int age;
void sleep();
void eat();
void study();
};
gg=G
3.结构体与类
1.为了照顾C程序员，所以在C++结构体尽量还是按照C风格来写
2.类比结构体更安全
区别：
结构体在默认情况下，它的成员都是公有的，在任何地方都可以访问
类在默认情况下，它的成员都私有的，在类的外部不能访问。
4.访问限定符
private: 私有的 只有在类的内部可以访问
public: 公有的 在类的内部和外部都可以访问
protected: 受保护的 只在类的内部和其子类可以访问
一般情况下，数据成员私有化，成员函数应该设为公有。
5.类的声明：
class 类名
{
public:
//公有成员（一般为函数）
private:
//私有成员（一般都是数据成员）
protected:
//受保护的成员
};
练习：
写一个类，其功能就是找出一个整型数组元素的最大值。
int array[5] = {1,2,3,4,5};
6.类的组织形式
1.声明一个类 应用放在头文件中
2.实现一个类 用一个.cpp文件来实现类
返回类型 类名::函数名（参数表）
｛｝
3.使用这个类
7.构造函数
构造函数主要用于为对象分配空间进行初始化。
构造函数是一种特殊的成员函数
构造函数的名字与类名要完全相同
构造函数没有返回值
构造函数在创建对象的时候 由系统自动调用，一定会调用，且只调用一次。
当我们在类中没有显式的声明构造函数时，编译器自动会创建一个构造函数，称为默认构造函数。
类名(参数表)
{}
一旦显式的声明了构造函数，系统不会再自动创建了。
构造函数也可以重载，也可以带默认参数
8.析构函数
在对象销毁时，自动调用，处理对象的善后工作。
最常用的用法：就是用来回收内存。
delete xxx
~类名()
{
}
析造函数也是一种特殊的成员函数
析构函数的名字是 ~类名
析构函数没有参数（意味着一个类里只能有一个析构函数）
由系统自动调用
析构函数也没有返回值
9.对象的创建与销毁
1.在栈中创建对象
类名 对象(构造函数参数);
Student s(参数);
2.在堆中创建对象
//int *p = new int;
类名 *对象指针名 = new 类名(构造实参);
student *s = new student;
3.在栈中创建对象数组
//int a[5];
类名 对象数组名[元素个数];
4.在堆中创建对象数组
int *p = new int[元素个数];
类名 *对象指针名 = new 类名[元素个数];
用new 创建的对象 一定要用delete 释放
练习： 实现一个电子时钟类
在构造函数中接收当前系统时间，以秒为单位运行
类的属性：时，分，秒
类的方法：构造函数
运行函数
对时间进行处理的函数
./myClock
17:13:50
int main()
{
MyClock c(...);
c.run();
return 0;
}
time(0);//获取系统时间，返回的是从1970年1月1日0点0分0秒到现在所经过的秒数
localtime();//把time得到的秒转为本地时间
#include<iostream>
using namespace std;
int main()
{
int a = 10;
int &ra = a;
cout << "ra = " << ra << endl;//10
a = 20;
cout << "ra = " << ra << endl;//20
ra = 30;
cout << "a = " << a << endl;//30
cout << "&a = "<< &a << endl;//
cout << "&ra = "<< &ra << endl;//
return 0;
}
#include<iostream>
using namespace std;
void swap(int a1,int b1)//交换不成功
{
int temp;
temp = a1;
a1 = b1;
b1 = temp;
}
void swap2(int *a,int *b)//使用指针作为参数，容易出错
{
int temp;
temp = *a;
*a = *b;
*b = temp;
}
void swap3(int &a1,int &b1)//使用引用作为参数
{
int temp;
temp = a1;
a1 = b1;
b1 = temp;
}
int main()
{
int a = 10;
int b = 20;
// swap(a,b);
// swap2(&a,&b);
swap3(a,b);
cout << "a = " << a << endl;
cout << "b = " << b << endl;
return 0;
}
#include<iostream>
using namespace std;
int& func(int& ra)
{
ra = ra + 1;
return ra;
}
int func2(int a)
{
return a;
}
int main()
{
int a = 10;
// int r = func(a);
// cout << "r = " << r << endl;
int r2 = func2(a);//r2 = 10
return 0;
}
#include<iostream>
using namespace std;
class student
{
public:
void sleep()
{
cout << "I am sleeping....." << endl;
}
// void eat();
// void study();
void show()
{
cout << num << endl;
cout << name << endl;
cout << age << endl;
}
private:
int num;
string name;
int age;
};
int main()
{
student s;
/*
s.num = 1001;
s.name = "zhangfei";
s.age = 20;
s.show();
s.sleep();
*/
return 0;
}
#include<iostream>
using namespace std;
class Test
{
public:
Test()
{
p = new int(100);
cout << "Test()" << endl;
}
void show()
{
cout << "p = " << *p << endl;
}
~Test()
{
delete p;
cout << "~Test()" << endl;
}
private:
int *p;
};
int main()
{
Test t;
t.show();//Test()
cout << "----------------" <<endl;
Test *t1 = new Test;//Test()
delete t1;//~Test()
cout << "----------------" <<endl;
//~Test()
return 0;
}
#include<iostream>
using namespace std;
class array_max
{
public:
/*
array_max()
{
max = 0;
arr = NULL;
arrSize = 0;
cout << "这里是默认构造函数" << endl;
}
array_max(int m)
{
max = m;
cout << "这是带参数的构造函数"<< endl;
}
*/
array_max(int m = 0)
{
max = m;
arr = NULL;
arrSize = 0;
cout << "这里有默认参数的构造函数" << endl;
}
~array_max()
{
cout << "这里是析构函数" << endl;
}
void getArray(int *p,int size)
{
arr = p;
arrSize = size;
}
void init()
{
max = 0;
arr = NULL;
arrSize = 0;
}
int findMax()
{
max = arr[0];
for(int i = 0; i < arrSize; i++)
{
if(arr[i] > max)
{
max = arr[i];
}
}
return max;
}
private:
int max;
int *arr;
int arrSize;
};
int main()
{
int arr[5] = {1,2,3,4,5};
array_max arrMax(100);
array_max a1;
// arrMax.init();//初始化
arrMax.getArray(arr,5);
int r = arrMax.findMax();
cout << r << endl;
return 0;
}
标签：
原文地址：http://www.cnblogs.com/liudehao/p/5686056.html
