- 浏览: 317733 次
- 性别:
- 来自: 南京
文章分类
最新评论
-
huangyunbin:
swc.advance(); 这个什么时候被调用是最核心的 ...
滑动窗口计数java实现 -
80后的童年2:
深入浅出MongoDB应用实战开发网盘地址:https://p ...
MongoDB 从入门到精通专题教程 -
rryymmoK:
深入浅出MongoDB应用实战开发下载地址:http://pa ...
MongoDB 从入门到精通专题教程 -
u012352249:
怎么支持多个窗口啊?
滑动窗口计数java实现 -
rryymmoK:
深入浅出MongoDB应用实战开发百度网盘下载:链接:http ...
MongoDB 从入门到精通专题教程
c++中字符串的处理,用string进行处理,实际上它是一个类.
因此这里的name就是一个对象.
name[下标],这样写不表示它是一个数组.
char s[100] = "Hello";//应该是存在了栈空间里
char* p = "Hello";//字符串存在常量区里,栈里只保存了一个地址
输入输出时会对字符串进行特殊的处理.
string不是C风格的字符串,是c++风格的,在c++里它会记录它的长度.
在C里我们用strlen(地址),而在c++里我们用obj.size();
在c++里我们用strlen(obj)是会出错的.
----------------------------------
c++风格:
可以直接输入输出,输入时不用考虑长度,自动会处理长度问题.
--------------------------------
C风格字符串 :
strcpy(地址,串)
也可以直接输入输出,在输入时,必须要考虑数组长度的问题,避免越界
cin.getline(地址,长度);
strcat(旧串,附加串) //注意长度
strcmp(串1,串2)//结果正,负,0
=================================================
常量函数 在函数后加const
无名对象:没有名字的对象,起到一个类型转换的作用.会的语句执行
完后立即释放.
单重继承:class Child:public Parent{};来自父类的私有成员不能
在子类中直接访问.子类还可以扩展自已的东西,从而拥有比父类更丰富的内容
.在创建时,会自动去调用父类的构造函数,如果要传参数,利用初始化列表传过
去.一个函数的形参是可以有默认值的,在声明的时候就要指定默认值,而不是
在定义时指定.初始化列表写在构造函数的函数头与函数体之间,因此必须在定
义时才能有的,声明不能有.声明写默认值,主义时写初始化列表.
覆盖:
虚继承:是对菱形继承关系,virtual关键字的使用
在Linux环境下用g++ fraction.cc进行编译连接,a.out运行可看到结果.
=================================================
* 多态 polymorphism
父类对象 人类
子类对像 司机类(小张)
学生类(小王同学)
子类对象总可以看成父类对象.
多态的本质
1,c++允许把派生类对象的地址赋给基类的指针
3,用基类的指针调用任何方法,c++都能找到相应的派生类的方法.
通过指针访问某个成员函数的时候,根据对象的真实类型执行子类中
相应的函数
多态的优势:统一管理,统一操作接口
有virtual关键字的函数称为虚函数.在声明定义分开时,声明时写.
多态的三个要素:
1,继承关系
2,调用的是虚函数
3,访问到的是对象自已(用批针或引用),不能是另一个对象.
对有虚函数的类,编译器会申请一片空间,形成一个虚函数表,把所有
的虚函数地址存在里面.所以多态是会有代价的.
* 抽象类
* 纯虚函数
有纯虚函数的类叫做抽象类.对于抽象类没必要写函数体,因为如果写
了会占用空间.
纯虚函数一定不会被调用.所以抽象类不允许创建对象.
只能用它来指向子类对象或是引用子类对象.
这样就保证了一定不会执行纯虚函数.
* 强制类型转换
(类型) 数据 类型 (数据)
不会改变源数据,根据类型产生新的数据,而++ -- = 可改变源数据.
1,静态转换,static_cast xxx_cast<类型>(数据)
数值类型之间,有类型的指针与 void* 之间转换.
无名类型支持的转换.
static_cast<A>(100) (A)100
2,const_cast 把常量转换成变量.
const X data;
const_cast<X>(data) //会重新产生一个变量
const_cast<X&>(data)=1; //就是对当前常量进行处理
volatile 不稳定的变量,基本不用
auto 自动,默认的,无需人为的去加
register 寄存器,
register int n;//将n存在寄存器里,效率较高
reinterpret_cast 重新解释内存,这也是最危险的转换,可以说是高手的游戏,
一般人请不要用.因为什么都可以转.一般用在不同类型指针之间转换.
reinterpret_cast<X*>(p) //这样用
3,动态类型转换 dynamic_cast
向上转换是安全的,向下转换就不一定了.
dynamic_cast<子类*>(父类地址) 失败 NULL
----------------------------
* 虚函数的使用
构造函数不能是虚函数:因为我们是想用多态,根据我们的情况去调子
类,而构造函数会首先调,不是主要调的,是自动调的,因此不能是虚函数
如果类中有任何一个成员函数是虚函数,那么析构函数应为虚函数.因
为我们想它会自动的去调相应的析构函数.
如果一个类肯定被用作其他派生类的基类,尽可能使用虚函数.甚至可
写成纯虚函数; 用=0;来代替函数体.
=================================================
=================================================
* 友员
* 静态成员
- 静态数据成员
- 静态函数成员
友员提供外面的函数或类直接访问某个类中私有成员的桥梁.
友员也可理解为授权给某一个函数或类.
在类的内部用 friend 声明;
请注意啦 : 友员不是成员
在实际开发中,凡是在函数中传递对象时,几乎都用引用,只要不改变
此对象,也会加const
* 静态数据成员
凡是所有对象共用一份的数据都是要声明为静态数据成员.
静态数据成员又称为类变量.
静态的函数成员叫类方法.
静态成员没必要创建一个对象初始化一次,一次性的初始化,不在构造函数中,
而是在所有的函数之外.
静态数据成员像全局变量一样,在所有函数之外初始化.
* 静态函数成员
静态函数不能去访问非静态的数据成员.
允许但不提倡用 对象.成员 来访问静态成员,类名::静态成员
string name; name.size(); name.c_str();
因此这里的name就是一个对象.
name[下标],这样写不表示它是一个数组.
char s[100] = "Hello";//应该是存在了栈空间里
char* p = "Hello";//字符串存在常量区里,栈里只保存了一个地址
输入输出时会对字符串进行特殊的处理.
string不是C风格的字符串,是c++风格的,在c++里它会记录它的长度.
在C里我们用strlen(地址),而在c++里我们用obj.size();
在c++里我们用strlen(obj)是会出错的.
----------------------------------
c++风格:
obj = "Hello"; obj[2] = '\0'; obj.size(); //返回5,注意这一点
可以直接输入输出,输入时不用考虑长度,自动会处理长度问题.
getline(cin,obj); obj += 附加串 //不用考虑空间问题 obj1 >(<,==,>=,<=,!=) obj2 //直接比,结果为true,false obj.c_str() ---> const char *
--------------------------------
C风格字符串 :
strcpy(地址,串)
也可以直接输入输出,在输入时,必须要考虑数组长度的问题,避免越界
cin.getline(地址,长度);
strcat(旧串,附加串) //注意长度
strcmp(串1,串2)//结果正,负,0
=================================================
常量函数 在函数后加const
无名对象:没有名字的对象,起到一个类型转换的作用.会的语句执行
完后立即释放.
单重继承:class Child:public Parent{};来自父类的私有成员不能
在子类中直接访问.子类还可以扩展自已的东西,从而拥有比父类更丰富的内容
.在创建时,会自动去调用父类的构造函数,如果要传参数,利用初始化列表传过
去.一个函数的形参是可以有默认值的,在声明的时候就要指定默认值,而不是
在定义时指定.初始化列表写在构造函数的函数头与函数体之间,因此必须在定
义时才能有的,声明不能有.声明写默认值,主义时写初始化列表.
覆盖:
虚继承:是对菱形继承关系,virtual关键字的使用
//关于继承的例子程序,显示代分数 #include <iostream> using namespace std; class Fract{ int n; int d; public: Fract():n(0),d(1){} Fract(int a, int b ):n(a),d(b){ reduce(); } void reduce(){ if(d<0 ){d=-d;n=-n;} if(d==0){cout << "ERROR" << endl;d=1;} int absn = (n<0?-n:n); for(int i=d;i>1;i--){ if(absn%i == 0 && d%i==0 ){ n /= i;d/= i; break; } } } void show(){ cout << n << '/' << d << endl; } double value(){ return (double)n/d; } }; class Dai : public Fract{ int i; public : Dai():i(0){} Dai( int ai, int an, int ad ) : i(ai),Fract(an,ad){} void show(){ cout << i << '(' ; Fract::show(); cout << ')'; } double value(){ return i+Fract::value(); } }; int main() { Dai d1; Dai d2(2,12,16); d1.show(); d2.show(); }
在Linux环境下用g++ fraction.cc进行编译连接,a.out运行可看到结果.
=================================================
* 多态 polymorphism
父类对象 人类
子类对像 司机类(小张)
学生类(小王同学)
子类对象总可以看成父类对象.
多态的本质
1,c++允许把派生类对象的地址赋给基类的指针
3,用基类的指针调用任何方法,c++都能找到相应的派生类的方法.
通过指针访问某个成员函数的时候,根据对象的真实类型执行子类中
相应的函数
多态的优势:统一管理,统一操作接口
有virtual关键字的函数称为虚函数.在声明定义分开时,声明时写.
多态的三个要素:
1,继承关系
2,调用的是虚函数
3,访问到的是对象自已(用批针或引用),不能是另一个对象.
//例子 #include <iostream> using namespace std; #include <string> class Animal{ string name; public: virtual void eat()=0;//一定不会被执行,纯虚函数 virtual void sleep(){ cout << "动物休息" << endl; } virtual void shout(){ cout << "动物叫" << endl; } };//注意分号 class Cat : public Animal{ public: virtual /* virtual 可写可不写 */ void eat(){ cout << "猫写猫粮" << endl; } void sleep(){ cout << "猫睡觉" << endl; } void shout(){ cout << "猫喵喵叫" << endl; } };//注意分号 class Dog : public Animal{ public : void eat(){ cout << "狗吃骨头" << endl; } void sleep(){ cout << "狗在睡觉" << endl; } void shout(){ cout << "我叫旺财" << endl; } };//分号不能少 class JiaFei : public Cat{ public : void eat(){ cout << "加非猫爱吃意大利面" << endl; } void sleep(){ cout << "加非猫睡在沙发上" << endl; } void shout(){ cout << "加非猫说下午好" << endl; } }; // 分号 class Player{ string name; public : Player( string n ) : name(n){} void play( Animal* p/*指针*/ ){ p->eat(); p->sleep(); p->shout(); } void play( Animal& p /*引用*/){ p.eat(); p.sleep(); p.shout(); } }; // 分号 int main() { //cout << sizeof(Animal) << endl; //输出8 Cat c; Dog d; JiaFei j; Player p1( "小小" ); Player p2( "蔡依林"); p1.play(&c); p2.play(&d); p2.play(&j); }
对有虚函数的类,编译器会申请一片空间,形成一个虚函数表,把所有
的虚函数地址存在里面.所以多态是会有代价的.
* 抽象类
* 纯虚函数
有纯虚函数的类叫做抽象类.对于抽象类没必要写函数体,因为如果写
了会占用空间.
纯虚函数一定不会被调用.所以抽象类不允许创建对象.
只能用它来指向子类对象或是引用子类对象.
这样就保证了一定不会执行纯虚函数.
* 强制类型转换
(类型) 数据 类型 (数据)
不会改变源数据,根据类型产生新的数据,而++ -- = 可改变源数据.
1,静态转换,static_cast xxx_cast<类型>(数据)
数值类型之间,有类型的指针与 void* 之间转换.
无名类型支持的转换.
static_cast<A>(100) (A)100
2,const_cast 把常量转换成变量.
const X data;
const_cast<X>(data) //会重新产生一个变量
const_cast<X&>(data)=1; //就是对当前常量进行处理
volatile 不稳定的变量,基本不用
auto 自动,默认的,无需人为的去加
register 寄存器,
register int n;//将n存在寄存器里,效率较高
reinterpret_cast 重新解释内存,这也是最危险的转换,可以说是高手的游戏,
一般人请不要用.因为什么都可以转.一般用在不同类型指针之间转换.
reinterpret_cast<X*>(p) //这样用
3,动态类型转换 dynamic_cast
向上转换是安全的,向下转换就不一定了.
dynamic_cast<子类*>(父类地址) 失败 NULL
//例子 #include <iostream> using namespace std; class A{ const int data; public: A(){} A(int d) : data(d){} void show() const{ cout << "data=" << data << endl; } virtual void set(int d ){ const_cast<int &>(data) = d; } ///////////这样可以修改常量 }; class B : public A{ public : void sayhello(){ cout << "welcome" << endl; } }; int main() { static_cast<A>(188).show(); A obj(200); obj.show(); obj.set(259); obj.show(); int i = 1; typedef unsigned char UC; UC *p = NULL; p = reinterpret_cast<UC*>(&i); for(int j=0; j<4; j++) cout <<(int)*( p++) << ' '; cout << endl; A oa; B ob; A* pa = &oa; B* pb = NULL; pb = dynamic_cast<B*>(pa); //pb=(B*)pa;这样转是不安全的. //dynamic_cast如果转换不了,会返 回一个NULL cout << "pb = " << pb << endl; }
----------------------------
* 虚函数的使用
构造函数不能是虚函数:因为我们是想用多态,根据我们的情况去调子
类,而构造函数会首先调,不是主要调的,是自动调的,因此不能是虚函数
如果类中有任何一个成员函数是虚函数,那么析构函数应为虚函数.因
为我们想它会自动的去调相应的析构函数.
如果一个类肯定被用作其他派生类的基类,尽可能使用虚函数.甚至可
写成纯虚函数; 用=0;来代替函数体.
//例子程序 class A{ public : A(){cout << "'A()" << endl;} ~A(){cout << "'~A()" << endl;} }; class B : public A { public : B(){cout << "'B()" << endl;} ~B(){cout << "'~B()" << endl;} }; int main() { A* p = new B; delete p; // 此句会导致调用析构函数 }
=================================================
=================================================
* 友员
* 静态成员
- 静态数据成员
- 静态函数成员
友员提供外面的函数或类直接访问某个类中私有成员的桥梁.
友员也可理解为授权给某一个函数或类.
在类的内部用 friend 声明;
请注意啦 : 友员不是成员
//友员函数 #include <iostream> using namespace std; class A { int data; public : A( int d = 0 ) : data( d ) {} void show( ) { cout << "data=" << data << endl; } friend A add(const A& a1,const A& a2 ); }; A add ( const A& a1, const A& a2 ){ //这样写可形成习惯. int sum = a1.data +a2.data; return A(sum); } int main() { A a1(20), a2(50); add(a1,a2).show(); }
//友员类 #include <iostream> using namespace std; class A { int data; public : A( int d = 0 ) : data( d ) {} void show( ) { cout << "data=" << data << endl; } friend A add(const A& a1,const A& a2 ); friend class B; }; class B { public : void twice(A& a){ a.data *= 2; //必须要通过 '对象名.成员' 来访问 } }; A add ( const A& a1, const A& a2 ){ int sum = a1.data + a2.data; return A(sum); } int main() { A oa(50); B ob; ob.twice(oa); oa.show(); }
在实际开发中,凡是在函数中传递对象时,几乎都用引用,只要不改变
此对象,也会加const
* 静态数据成员
凡是所有对象共用一份的数据都是要声明为静态数据成员.
静态数据成员又称为类变量.
静态的函数成员叫类方法.
静态成员没必要创建一个对象初始化一次,一次性的初始化,不在构造函数中,
而是在所有的函数之外.
静态数据成员像全局变量一样,在所有函数之外初始化.
//例程 #include <iostream> using namespace std; class Sd{ public : string name; static string teacher; static int room; Sd( const string& n) : name(n){ } void show(){ cout << "我是" << name << ",在" << room << "教室听" << teacher << "上课" << endl; } }; string Sd :: teacher = "小陈";// 静态成员要这样初始化 int Sd :: room = 213; int main() { Sd s1("伯乐"); Sd s2("蔡依林"); Sd s3("古天乐"); s1.show(); s2.show(); s3.show(); }
* 静态函数成员
静态函数不能去访问非静态的数据成员.
允许但不提倡用 对象.成员 来访问静态成员,类名::静态成员
#include <iostream> using namespace std; class Sd{ public : string name; static string teacher; static int room; #include <iostream> using namespace std; class Sd{ public : string name; static string teacher; static int room; Sd( const string& n) : name(n){ } void show(){ #include <iostream> using namespace std; class Sd{ public : string name; static string teacher; static int room; Sd( const string& n) : name(n){ } void show(){ cout << "我是" << name << ",在" << room << "教室听" << teacher << "上课" << endl; } static void newTeacher( const string& t){ teacher = t; } }; string Sd :: teacher = "小陈";// 静态成员要这样初始化 int Sd :: room = 213; int main() { Sd s1("伯乐"); Sd s2("蔡依林"); Sd s3("古天乐"); s1.show(); s2.show(); s3.show(); Sd::newTeacher("天使"); //通过类名访问静态函数 s1.show(); s2.show(); s3.show(); }
发表评论
-
UC++之目录和文件操作
2009-06-05 11:55 1246* UC + 文件系统 - 目 ... -
用c++实现二叉树增删改查和快速排序算法
2009-06-02 13:18 2583//快速排序 #include <iostream ... -
快速排序完整示例
2009-06-01 21:04 1076#include <iostream> usin ... -
C++容器与迭代器
2009-06-01 17:55 1975* 容器的迭代器还有几种: + iterator:正常迭 ... -
c++排序算法与模板和STL
2009-05-31 13:32 1808* 冒泡排序 一轮比较所有相邻数据对,如果顺序不合适就交换, ... -
C++算法与二叉树的实现
2009-05-30 18:35 2484* 输出格式控制 + 成员函数:width fill pr ... -
c++链表 异常 内部类 输出格式控制
2009-05-29 21:36 1676C(控制台) F(文件) ------------- ... -
C++之I/O
2009-05-27 21:26 1855* 重载 + 拷贝构造函数A(const A& o ... -
C++拷贝构造函数与运算符重载
2009-05-26 20:32 2401拷贝构造函数与运算符的重载 * 多态 - 前堤:继承,虚函 ... -
类的继承
2009-05-24 09:42 9781,如何定义,实现一个类 ... -
面向对象编程
2009-05-23 19:20 697//倒计时 #include <iostr ... -
C++ 面向对象
2009-05-23 15:40 925* 指针简单总结 //接受命令行参数的函数 int main ... -
C与C++中的time相关函数
2009-05-23 14:03 1293本文从介绍基础概念入手,探讨了在C/C++中对日期和时间操作所 ... -
c++指针续
2009-05-23 11:16 960//常指针,或叫定指针:指 ... -
C++指针
2009-05-22 19:22 1158C++ 里有字符串类型string ,最大可支持1G,可用st ... -
数组本质
2009-05-21 18:52 1214数组是一片连续的内存空间,定义时一般指明大小和类型,这样编译器 ... -
C++用递归解决汉诺塔问题(续)
2009-05-19 12:16 914#include <iostream.h> ... -
c++ 递归实例二
2009-05-18 22:37 1646#include <iostream.h> ... -
C++用递归解决汉诺塔问题
2009-05-18 21:54 2538递归确实是一个不错的算法,可以将原来很复杂的问题简化.这里要注 ... -
C++ 入门
2009-05-15 21:31 0一次性修改LINUX环境变量:(bash)export $PA ...
相关推荐
使用标准C++的类型转换符:static_cast、dynamic_cast、reinterpret_cast和const_cast。 const_cast,字面上理解就是去const属性。 static_cast,命名上理解是静态类型转换。如int转换成char。 dynamic_cast,...
C++的类型转换详细介绍 1、类型转换名称和语法 C风格的强制类型转换(Type Cast)很简单,不管什么类型的转换统统是: TYPE b = (TYPE)a C++风格的类型转换...如子类和父类之间的多态类型转换。 const_cast
C++风格的类型转换提供了4种类型转换操作符来应对不同场合的应用。 const_cast,字面上理解就是去const属性。 static_cast,命名上理解是静态类型转换。如int转换成char。 dynamic_cast,命名上理解是动态类型转换。...
11.6.4自动类型转换的缺陷 11.7小结 11.8练习 第12章 动态对象创建 12.1对象创建 12.1.1C从堆中获取存储单元的方法 12.1.2运算符new 12.1.3运算符delete 12.1.4一个简单的例子 12.1.5内存管理的开销 12.2重新设计...
本书循序渐进地讲述了C++的基础知识、C++程序的组成及其开发过程、C++程序中的数据、表达式和语句、控制程序流程、数组与字符串、指针与引用、使用函数、函数模板、错误和异常处理、宏和预编译、面向对象的开发、...
第1章 VC与C++开发基础 1.1 C++面向对象特性 实例l:实现C++类的多重继承 实例2:使用虚函数实现运行时多态 实例3:使用操作符重载实现编译多态——复数的加法运算 实例4:使用函数模板实现不同数据...
2.C++内存模型,命名空间和数据类型; 3.C++函数,引用,内联函数,函数模板,函数重载; 4.面向对象编程(OOP),类和对象; 5.构造器,拷贝构造,析构,new/delete; 6.运算符重载;面向对象编程(OOP),封装; 7.面向对象...
2.3 程序转换语意学(Program Transformation Semantics) 明确的初始化操作(Explicit Initialization) 参数的初始化(Argument Initialization) 返回值的初始化(Return Value Initialization) 在使用者层面做...
C++更加安全,增加了const常量、引用、四类cast转换(static_cast、dynamic_cast、const_cast、reinterpret_cast)、智能指针、try—catch等等; C++可复用性高,C++引入了模板的概念,后面在此基础上,实现了方便...
4. 类型转换高级 Advacned Class Type-casting 5. 预处理指令 Preprocessor Directives 7. C++ 标准函数库 C++ Standard Library 1. 文件的输入输出 Input/Output with files C++基础教程简介 怎样使用本...
第1章 C++概述与软件开发 1.1 什么是C语言和C++ 1.1.1 C和C++历史回顾 1.1.2 C/C++是一门编译语言 1.1.3 为什么许多程序员都选择C++ 1.2 什么是面向对象 1.2.1 C++程序并不一定是面向对象的 1.2.2 一个简单的面向...
从这部分开始我们除了利用内存的信息打印来进行探索外,更多的会通过跟踪和观察编译器产生的汇编代码来理解编译器对这些语言特性的实现方式。汇编方面知识的讨论超出了本文的范围,我只对和我们讨论相关的汇编代码...
C++增加了 const 常量、引用、强制类型转换、智能指针、Lambda 匿名 函数、右值引用等新特性,功能语法更为灵活复杂; • C++可复用性高,引入了模板概念,在此基础上实现了 STL 标准模板库, 大大方便了开发...
第1章 语言基础 1 ...0080 C++.NET中数据类型转换的方法 33 0081 在C++.NET中如何定义具有输出参数的函数 33 0082 C++.NET中如何实现方法的默认参数 33 0083 在C++.NET中如何获取系统信息 34
条款24:若有所参数皆需类型转换,请为此采用non-member函数 条款25:考虑写出一个不抛异常的swap函数 5.实现 条款26:尽可能延后变量定义式的出现时间 条款27:尽量少做转型动作 条款28:避免返回handles指向...
3.1 ITEM M1:指针与引用的区别8 3.2 ITEM M2:尽量使用 C++风格的类型转换10 3.3 ITEM M3:不要对数组使用多态14 3.4
3.1 ITEM M1:指针与引用的区别8 3.2 ITEM M2:尽量使用 C++风格的类型转换10 3.3 ITEM M3:不要对数组使用多态14 3.4
派生一个类的原因并非总是为了继承或是添加新的成员,有时是为了...在C++中,这种多态性可以通过重载多态(函数和运算符重载),强制重载(类型强制转换),类型参数化多态(模板) ,包含多态(继承与虚函数)四种方式
第1章 C++概述与软件开发 1.1 什么是C语言和C++ 1.1.1 C和C++历史回顾 1.1.2 C/C++是一门编译语言 1.1.3 为什么许多程序员都选择C++ 1.2 什么是面向对象 1.2.1 C++程序并不一定是面向对象的 1.2.2 一个简单的面向...