原著：www.geocities.jp/ky_webid/cpp
第25章 异常
try包含你要防护的代码,称为防护块. 防护块如果出现异常,会自动生成异常对象并抛出.
catch捕捉特定的异常,并在其中进行适当处理.
throw可以直接抛出/产生异常,导致控制流程转到catch块.
try{
throw( "例外が発生しました" );
std::cout << "この文は表示されません" << std::endl;
}catch( int num ){
std::cout << num << std::endl;
std::cout << "例外がここでキャッチされた场合、この文は表示されます" << std::endl;
}catch( const char* str ){
std::cout << str << std::endl;
std::cout << "例外がここでキャッチされた场合、この文は表示されます" << std::endl;
}第26章 模板
函数
template<class T> T max(const T& a, const T& b) {
return (a>b) ? (a):(b);
}template <class T>
class CStack{
public:
enum{ STACK_SIZE = 100 }; // スタックサイズ
CStack(){ m_sp = 0; } // コンストラクタ
void push(const T& data); // プッシュ
T pop(); // ポップ
private:
T m_data[STACK_SIZE]; // スタック本体
int m_sp; // スタックポインタ
};// プッシュ
template<class T> void CStack<T>::push(const T& data){
if( m_sp >= STACK_SIZE ) // スタックが満杯
{
std::cout << "スタックが満杯でプッシュできません" << std::endl;
return;
}
m_data[m_sp++] = data;
std::cout << data << "がプッシュされました" << std::endl;
}// ポップ
template<class T> T CStack<T>::pop(void){
if( m_sp <= 0 ) // スタックが空{
std::cout << "スタックが空でポップできません" << std::endl;
return 0;
}
T data = m_data[--m_sp];
std::cout << data << "がポップされました" << std::endl;
return data;
}
// main.cpp
#include "stack.h"
int main(){
CStack<int> stack; // int型を扱うスタックを生成
stack.push( 100 );
stack.push( 200 );
stack.pop();
stack.pop();
stack.pop();
return 0;
}
#include <cstddef>
#include <iostream>
// バッファテンプレート
template <class T, std::size_t SIZE>
class CBuffer{
public:// コンストラクタ
CBuffer(){}// 要素数を返す
std::size_t GetSize() const{
return SIZE;
}
private:
T m_data[SIZE]; // バッファ领域
};
int main(){
CBuffer<int, 5>intBuffer;
std::cout << intBuffer.GetSize() << std::endl;
return 0;
}重载类型转换运算符
class CSample{
public:// コンストラクタ
CSample(float f){ m_float = f; } // intへの型変换
operator int() const { return static_cast<int>( m_float ); }// floatの値を返す
float get() const { return m_float; }
private:
float m_float;
};
#include <iostream>
#include "sample.h"
int main(){
CSample obj( 2.68f );
std::cout << obj.get() << std::endl; // 普通にfloatの2.68を出力する
int num = obj + 100; // num = obj.operator int() + 100;
std::cout << num << std::endl; // 102を出力
return 0;
}class COuter{
public:// 内部クラスの定义
class CInner{
public:
CInner(){ m_num = 100; }
int m_num;
};
int get() const { return m_obj.m_num; }
private:
CInner m_obj; // 内部クラスのインスタンス
};
COuter::CInner g_obj; // 内部クラスのインスタンス
#include <iostream>
int main(){
using namespace std;
COuter out;
cout << out.get() << endl;
cout << g_obj.m_num << endl;
return 0;
}
#include <iostream>
class COuter{
public:// 无名クラスの定义
class{
public:int m_num;
};
void set(int num){ m_num = num; }
};
int main(){
using namespace std;
COuter out;
out.set( 100 );
cout << out.m_num << endl;
return 0;
}局部类，局部类的使用。区别于内部类，是函数体内。
void function(){// ローカルクラスの定义
class CLocal : public CSample // CSampleが継承できる {
public:
CLocal(int num){ m_num = num; }
int get() const{ return m_num; }
private:
int m_num;
};
CLocal local( 123 );
std::cout << local.get() << std::endl;
}第32章 private,protect的继承
类的private/protect继承，继承的子类可以访问public&protect，不能访问private
在外部可以使用类内public成员，protect和private不能使用。
不同级别的继承：
-----------------------------------------------------------
private继承
基类成员
内部访问
对象访问
------------------------------------------------------------
public继承
基类成员
内部访问
对象访问
------------------------------------------------------------
protected继承
基类成员
内部访问
对象访问
------------------------------------------------------------
第32章 多重继承
class CBase1{
public:
virtual void func(); // 何かする
};
class CBase2{
public:
virtual void func(); // 何かする
};
class CSub : public CBase1, public CBase2
{
public:
void func(); // CBase1::func()をオーバーライドしているつもり
void func(); // CBase2::func()をオーバーライドしているつもり
};
int main()
{
CSub* sub = new CSub();
sub->CBase1::func(); // CBase1::func()を呼び出すように明示する
delete sub;
return 0;
}第34章 成员函数指针
// メンバ関数ポインタを取得
void (CSample::*pFunc)() = &CSample::func;
// .*演算子でのアクセス
(obj.*pFunc)();
// ->*演算子でのアクセス
(pObj->*pFunc)();静态成员函数获取
class CSample{
public:
static void func();
};
int main(){// 静的メンバ関数ポインタを取得
void (*pFunc)() = &CSample::func; // 関数ポインタ経由でのアクセス
pFunc();
return 0;
}第36章 Replacement New
char global_area[1000]; // グローバル领域
int main(){// グローバル领域に、char10个分の领域を确保して、そこを指すポインタを得
char* p = new(global_area) char[10];
::strcpy( p, "aaaaaaaaa" );
}
Replacement Delete 就比较复杂了
class CSample{
public: // デストラクタ
~CSample(){ std::cout << "デストラクタ" << std::endl; }
// CSampleクラス用のplacement newとplacement deleteを定义
static void* operator new(size_t size, void* buf){ return buf; }
static void operator delete(void* p, void* buf){}
static void operator delete(void* p){} // VC6.0では必要
};
char global_area[1000]; // グローバル领域
int main(){
CSample *p = new(global_area) CSample; // placement new
if( p != NULL ) // 领域确保に成功していることを确认 {
p->~CSample(); // 明示的にデストラクタを呼び出す
CSample::operator delete( p, global_area ); // placement delete
}
return 0;
}
第37章 模板特殊化
1.模板int版本
#include <iostream>
// 泛用バージョン
template <class T>
class CSample{
public:
CSample(){
std::cout << "class T version" << std::endl;
}
};
// int型専用バージョン
template <>class CSample<int> {
public:
CSample(){ std::cout << "int version" << std::endl; }
};
int main(){
CSample<int> obj1;
CSample<double> obj2;
return 0;
}
结果：
int version
class T version
int version
class T version
#include <iostream>
// 泛用バージョン
template <class T>
class CSample{
public:
CSample(){ std::cout << "class T version" << std::endl; }
};
// ポインタ型専用バージョン
template <class T>
class CSample<T*>{
public:
CSample(){ std::cout << "pointer version" << std::endl; }
};
int main(){
CSample<int> obj1;
CSample<int*> obj2;
return 0;
}class T version
pointer version
第38章 与C语言联合
/* test.h */
#ifdef __cplusplus
extern "C" {
#endif
int function(int num);
int function2(int num);
int function3(int num);
#ifdef __cplusplus
}
#endif
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
