c++ステップアップの準備(一)
59970 ワード
文書ディレクトリ 1親入力子プロセス 2異常捕獲 3構造体と関数コールバック 4動的配列 5テンプレート 6類テンプレート 7容器vector 8入れ子容器 9 new 10リファレンス& 10.1ポインタ定数 10.2定数参照 11関数 11.1関数リロード 12パッケージ継承マルチステート 12.1コピーコンストラクタ 12.2浅いコピー深いコピー 13初期化リスト 14 this 15友元 16演算子リロード 17マルチステート 17.1多態原理 18純虚関数抽象クラス 19虚析純虚析 20テンプレートファイル作成
Linuxシステムプログラミング
c/c++プログラミング
1親プロセス
2異常捕捉
3構造体と関数コールバック
4動的配列
5テンプレート
6種類のテンプレート
7容器vector
8ネストされたコンテナ
9 new
10参照&
10.1ポインタ定数
参照の本質はポインタ定数です.
10.2定数参照
11関数
11.1関数の再ロード
12パッケージ継承マルチステート
12.1コピーコンストラクタ
12.2浅いコピーと深いコピー
13初期化リスト
14 this
15友元
16演算子の再ロード
既存の演算子を定義し、新しい機能に割り当て、新しいタイプに適応します.
17マルチステート
静的(関数リロード、演算子リロード)、動的(派生クラス、虚関数).
17.1多態原理
親クラスの虚関数では、虚関数はポインタに似ており、虚関数テーブルを指します.子クラスが親クラスを継承すると、虚関数テーブルが再コピーされるので、子クラスで虚関数を書き換え、指向を変更します.
18純虚関数抽象クラス
19虚析構造純虚析構造
純粋な虚析構造は実現する必要がある
20テンプレートファイル作成
.hpp .cpp
Linuxシステムプログラミング
c/c++プログラミング
1親プロセス
#include
");
}
if (pid == 0)
printf("child: my = %d, parent = %d
", getpid(), getppid());
//getpid() pid，getppid() pid
else
printf("parent: my = %d, child = %d
", getpid(), pid);
return 0;
}/* fork ， ，fork PID
fork ， ，fork 0*/
2異常捕捉
#include
using namespace std;
class MyClass
{
//
};
class myclass :public MyClass {
//
};
/* try catch */
// ，
//int main() {
//
// try
// {
// throw MyClass();
// }
//
// catch (myclass) {
//
// cout << "myclass " << endl;
// }
// catch (MyClass)
// {
// cout << "Myclass " << endl;
// }
// return 0;
//}
int main() {
try
{
throw myclass();//
}
//
catch (MyClass)
{
cout << "Myclass " << endl;
}
catch (myclass) {
cout << "myclass " << endl;
}
return 0;
}//
/*
catch (MyClass)
{
cout << "Myclass " << endl;
}
*/
3構造体と関数コールバック
#include
2-----------------------%d
", addr);
//
addr->addr2[3] = 1;
addr->addr2[4] = 2;
printf("%d
", addr->addr2[3]);
printf("%d
", addr->addr2[4]);
}
void test1() {
struct dynamicArray* addr = malloc(sizeof(struct dynamicArray));
addr->addr1 = malloc(sizeof(void*) * 5);
printf("1-----------------------%d
", addr);
//
addr->addr1 = 1;
printf("%d
", addr->addr1);
}
//
//
void back_func_test(void* back_func(void*,void*)) {
int* x;
int y = 10;
x = &y;
back_func(*x,*x+10);
}
// ， ，
//
void back1(void *data1,void *data2) {
// *x
printf("%d
", data1);
//printf("%d
", data2);
}
void back2(void* data1, void* data2) {
// *x，*x+10
printf("%d
", data1);
printf("%d
", data2);
}
int main() {
/*test1();
test2();*/
printf(" 1
");
back_func_test(back1);
printf(" 2
");
back_func_test(back2);
return 0;
}
4動的配列
#include
");
return;
}
return arr;
}
// (data) (arr) (pos)
void insertArray(struct dynamicArray* arr, int pos, void* data) {
if (arr) {
if (pos<0 || pos>arr->Size)
{
// ，
pos = arr->Size;
}
}
if (data == NULL)
{
}
if (arr) {
if (arr->capacity == arr->Size)
{
// ，
int newCapacity = arr->capacity * 2;
void** newSpace = malloc(sizeof(void*) * newCapacity);
// ，
if (newSpace)
{
memcpy(newSpace, arr->addr, sizeof(void*) * arr->capacity);
//
free(arr->addr);
//
arr->addr = newSpace;
arr->capacity = newCapacity;
//
}
}
//
for (int i = arr->Size - 1; i >= pos; i--)
{
arr->addr[i + 1] = arr->addr[i];
}
arr->addr[pos] = data;
arr->Size++;//
}
}
//
void foreachArray(struct dynamicArray* arr,void(*myprint)(void*)){
if (arr==NULL)
{
}
if (myprint==NULL)
{
}
for (int i = 0; i < arr->Size; i++)
{
myprint(arr->addr[i]);
}
}
//
void delArray(struct dynamicArray* arr,int pos) {
if (arr)
{
}
if (pos<0||pos>arr->Size-1)
{
return;
}
for (int i = pos; i < arr->Size-1; i++)
{
arr->addr[i] = arr->addr[i + 1];
}
arr->Size--;
}
//
void delvalueArray(struct dynamicArray* arr, void* data,int(*myCompare(void*,void*))) {
if (arr==NULL)
{
}
if (data==NULL)
{
}
for (int i = 0; i < arr->Size-1; i++)
{
if (myCompare(arr->addr[i],data))
{
delArray(arr, i);
break;
}
}
}
struct Person
{
char name[32];
int age;
};
//
void myprint(void* data) {
struct Person* p = data;
printf("%s %d
", p->name, p->age);
}
int myCompare(void* data1, void* data2) {
struct Person *p1 = data1;
struct Person *p2 = data2;//
return strcmp(p1->name,p2->name)==0 && (p1->age == p2->age);
}
//
void desArray(struct dynamicArray* arr) {
if (arr==NULL)
{
}
// ，
if (arr->addr!=NULL)
{
free(arr->addr);
arr->addr = NULL;
}
free(arr);
arr = NULL;
printf("end
");
}
void test01() {
struct dynamicArray* ARR=initArray(5);
//
struct Person p1 = {
"yi",20 };
struct Person p2 = {
"er",20 };
struct Person p3 = {
"san",20 };
struct Person p4 = {
"si",20 };
struct Person p5 = {
"wu",20 };
struct Person p6 = {
"liu",20 };
//
printf("
----%d %d
", ARR->capacity, ARR->Size);
insertArray(ARR, 0, &p1);
insertArray(ARR, 1, &p2);
insertArray(ARR, 2, &p3);
insertArray(ARR, -1, &p4);
insertArray(ARR, 3, &p5);
insertArray(ARR, 4, &p6);
//
printf("
----%d %d
", ARR->capacity, ARR->Size);
foreachArray(ARR, myprint);
delArray(ARR, 1);// “1”
printf("--------------------
");
foreachArray(ARR, myprint);
printf("--------------------
");
struct Person p = {
"san",20 };
delvalueArray(ARR,&p,myCompare);
foreachArray(ARR, myprint);
desArray(ARR);
}
int main() {
int a[32] = {
0 };
test01();
}
5テンプレート
#include
using namespace std;
//
/*
template ( ,...){
//
}
*/
// template
// <> ( )
// 1. (class / typedef)
// 2. ( )
// Type int double
template
Type max_us(Type x, Type y) {
return x > y ? x : y;
}
//
template
Type max_arr(Type arr[len]) {
Type ret = arr[0];
for (int i = 1; i < len; i++)
{
ret = (arr[i] > ret ? arr[i] : ret);
}
return ret;
}
// , 、
char* max_us(char* a, char* b) {
if (strcmp(a,b))
{
return a;
}
else
{
return b;
}
}
//
int main() {
int i = max_us(8, 9);
double j = max_us(9.1, 10.9);
//
//
float k = max_us(8.1f, 3);
cout << i << endl;
cout << j << endl;
cout << k << endl;
int a[5] = { 1,4,2,9,6 };
//
int max_a = max_arr(a);
cout << max_a << endl;
cout << " " << endl;
cout << max_us('a', 'n') << endl;
cout << max_us(9, 10) << endl;
cout << "end" << endl;
return 0;
}
6種類のテンプレート
#include
using namespace std;
/*
template class
{
//
}
template
:: ( )
{
//
}
，
， ，
*/
template
class Container
{
Type u;
public:
void begin2(const Type& itnew);//
};
template void Container::begin2(const Type& p) {
//
u = p;
cout << u << endl;
}
int main() {
Container myContainer;//
int i = 100;
myContainer.begin2(i);
}
7容器vector
#include
#include
#include
#include
using namespace std;
//vector ( )
class person {
public:
person(string name, int age) {
this->name = name;
this->age = age;
}
string name;
int age;
};
void test02() {
vector vp;
person p1("a", 10);
person p2("b", 20);
person p3("c", 30);
//
vp.push_back(p1);
vp.push_back(p2);
vp.push_back(p3);
//
for (vector::iterator it = vp.begin(); it!= vp.end(); it++) {
cout << (*it).name << endl;
cout << (*it).age << endl;
//cout << it->name << endl;
}
}
void test03() {
vector vp;
person p1("a", 10);
person p2("b", 20);
person p3("c", 30);
//
vp.push_back(&p1);
vp.push_back(&p2);
vp.push_back(&p3);
//
for (vector::iterator it = vp.begin(); it != vp.end(); it++) {
cout << (*it)->name << endl;
cout << (*it)->age << endl;
}
}
//vector ( )
void myprint(int val)
{
cout << val << endl;
}
void test01() {
// varray
vector varray;
varray.push_back(10);//
varray.push_back(90);
varray.push_back(19);
//
vector::iterator itbegin = varray.begin();
//
vector::iterator itend = varray.end();
//
while (itbegin!=itend)
{
cout << *itbegin << endl;
itbegin++;
}
// 2
for (vector::iterator it = varray.begin(); it != varray.end(); it++) {
cout << *it << endl;
}
// 3
for_each (varray.begin(), varray.end(), myprint);
}
int main() {
//test01();
/*test02();*/
test03();
cout << "----------------" << endl;
}
8ネストされたコンテナ
#include
#include
#include
#include
using namespace std;
void test01() {
//
vector> vv;
vector v1;
vector v2;
vector v3;
for (int i = 0; i < 3; i++)
{
v1.push_back(i + 2);
v2.push_back(i + 3);
v3.push_back(i + 4);
//
}
vv.push_back(v1);
vv.push_back(v2);
vv.push_back(v3);
//
for (vector> ::iterator it=vv.begin();it!=vv.end(); it++){
//
for (vector::iterator vit = (*it).begin();vit!=(*it).end(); vit++)
{
//
cout << " "< 9 new
#include
using namespace std;
void fun() {
int* p = new int(10);
//p , 10
cout << *p << endl;
delete p;
p = NULL;
}
void funarr() {
int* p1 = new int[10];
//p , 10
for (int i = 0; i < 10; i++)
{
p1[i] = i + 100;
}
for (int i = 0; i < 10; i++)
{
cout << p1[i] << endl;
}
// ( [])
delete[]p1;
p1 = NULL;
}
int main() {
fun();
cout << "-------------" << endl;
funarr();
return 0;
}
10参照&
10.1ポインタ定数
参照の本質はポインタ定数です.
#include
using namespace std;
/*
& =
*/
//
void swap(int &a,int &b) {
int temp;
temp = a;
a = b;
b = temp;
cout << "A=" << a << " B=" << b << endl;
}
//
int& test01() {
int a = 10;
return a;
}
int& test02() {
static int a = 16;//
return a;
}
int global = 190;//
int& test03() {
return global;
}
int main() {
int a=1;
int b = 9;
//
int& A = a;//
//int& A = b;// ( a )
cout << A << endl;
int a1 = 10;
int b1 = 18;
swap(a1, b1);//
cout << "-----------------" << endl;
int& ref = test01();
cout << ref << endl;
cout << ref << endl;
// , , ,
cout << "-----------------" << endl;
int gl = test03();
cout << gl << endl;
cout << gl << endl;//
cout << "-----------------" << endl;
int& ref02 = test02();
cout << ref02 << endl;
cout << ref02 << endl;
test02() = 1000;// , [ ]
cout << ref02 << endl;
cout << ref02 << endl;
cout << "-----------------" << endl;
int e = 10;
int e2 = 1;
int* const f = &e;// , ,
cout << *f << endl;
cout << "-----------------" << endl;
const int* f2 = &e;// , ,
cout << *f2 << endl;
f2 = &e2;
cout << *f2 << endl;
return 0;
}
10.2定数参照
#include
using namespace std;
void test01(const int& a) {
// , ,
//a = 100;// ,
cout << a << endl;
}
int main() {
int a = 11;
//int& b = 10;//
const int& b = 10;
test01(a);
return 0;
}
11関数
#include
using namespace std;
void test01(int a, int b, int c = 10);
// ,
void test01(int a,int b,int c) {
int sum;
sum = a + b + c;
cout << sum << endl;
}
//
//
void test02(int a,int =10) {
cout < 11.1関数の再ロード
#include
using namespace std;
void func(int& a) {
cout << "int& a" << endl;
}
void func(const int& a) {
cout << "const int& a" << endl;
}
int main() {
int a = 10;
func(a);
func(1);
return 0;
}
12パッケージ継承マルチステート
12.1コピーコンストラクタ
#include
using namespace std;
//
class Person {
public:
Person(int age) {
this->cage = age;
cout << this->cage << endl;
}
Person(const Person& p) {
//
this->cage = p.cage;
cout << this->cage << endl;
cout << " " << endl;
}
~Person() {
//
cout << " " << endl;
}
private:
int cage;
};
void test01() {
//
Person p1(20);
Person p2(p1);
}
void test02(Person p) {
}
int main() {
test01();
return 0;
}
12.2浅いコピーと深いコピー
#include
using namespace std;
class MyClass
{
public:
int cage;
int *cheight;
//
MyClass(int age,int height) {
this->cheight = new int(height);
//
this->cage = age;
}
MyClass(const MyClass& p) {
//
cage = p.cage;
//cheight=p.cheight;//
cheight = new int(*p.cheight);
}
/* 。
* : , 。
* , p1 p1 *cheight ,
* p, p *cheight ,
* p p1
* 【cage】 【cage】
* 【*cheight】\ /【*cheight】
* 【 】
*/
/*
* p p1
* 【cage】 【cage】
* 【*cheight】\ 【*cheight】\
* 【 】 【 】
*/
~MyClass();
};
MyClass::~MyClass()
{
if (cheight!=NULL)
{
delete cheight;
cheight = NULL;
}
cout << " " << endl;
cout << cheight << endl;
}
void test01() {
MyClass p(10,99);
MyClass p1(p);//
std::cout << p.cage << " "< 13初期化リスト
14 this
15友元
16演算子の再ロード
既存の演算子を定義し、新しい機能に割り当て、新しいタイプに適応します.
#include
using namespace std;
class Person {
public:
// +
Person operator+(Person& p) {
Person temp;
temp.age = this->age + p.age;
temp.height = this->height + p.height;
return temp;
}
int age;
int height;
};
// +
//Person operator+ (Person& p1,Person& p2) {
// Person temp;
// temp.age = p1.age + p2.age;
// temp.height = p1.height + p2.height;
//
// return temp;
//}
void test01() {
Person test;
Person p1;
p1.age = 10;
p1.height = 99;
Person p2;
p2.age = 11;
p2.height = 100;
test = p1 + p2;
cout << test.age << " " << test.height << endl;
}
int main() {
test01();// 。
/*
Person p3=p1.operator+(p2);
Person p3=operator+(p1,p2);
*/
return 0;
}
#include
using namespace std;
class Person {
public:
int operator()(int a, int b){
return a + b;
}
};
void test01() {
int a = 9;
int b = 10;
int temp;
Person p;
temp=p(a, b);// (),
cout< 17マルチステート
静的(関数リロード、演算子リロード)、動的(派生クラス、虚関数).
#include
using namespace std;
class Animal {
public:
/*void speak1() {
cout << " speak" << endl;
}*/
//
virtual void speak1() {
cout << " speak" << endl;
}
};//
//
class cat :public Animal {
public:
void speak1() {
cout << " speak" << endl;
}
};
class dog :public Animal {
public://
// : 、 、
void speak1() {
cout << " speak" << endl;
}
};
void dospeak(Animal& animal) {
animal.speak1();
}
int main() {
// :
cat c1;
dospeak(c1);// ,
// ,
/*
* :
*
*
* :
* ,
*/
dog d1;
dospeak(d1);// ,
return 0;
}
17.1多態原理
親クラスの虚関数では、虚関数はポインタに似ており、虚関数テーブルを指します.子クラスが親クラスを継承すると、虚関数テーブルが再コピーされるので、子クラスで虚関数を書き換え、指向を変更します.
18純虚関数抽象クラス
#include
using namespace std;
class Person {
public:
virtual void func()=0;
//
//
//
// ( )
};
class Son :public Person{
virtual void func() {
cout << "Son " << endl;
// ( ) ,
}
};
int main() {
//Person p;
//new Person;//
Person* p = new Son;
/*
* ,new ,
*/
p->func();
return 0;
}
19虚析構造純虚析構造
#include
#include
using namespace std;
//
class Person {
public:
Person() {
cout<speak1();
// , ,
// :son (~son6() )
// :
delete p;
//
}
int main() {
test01();//
return 0;
}
純粋な虚析構造は実現する必要がある
20テンプレートファイル作成
.hpp .cpp
#pragma once
#include
#include
//
using namespace std;
//
template
class Person {
public:
Person(T1 name, T2 age);
void showPerson();//
T1 mname;
T2 mage;
};
/*----------------------------------------*/
template
Person::Person(T1 name, T2 age) {
this->mname = name;
this->mage = age;//
}
/*----------------------------------------*/
template
void Person::showPerson() {
//
cout << " :" << this->mname << " " << this->mage << endl;
}
/*-------------------------------------
#include"practice.hpp"
int main() {
Person obj("Tom", 10);
obj.showPerson();
return 0;
}