Android NDK基础18:C++_构造函数_析构函数_拷贝构造函数

函数

函数默认参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//函数默认参数
void print(int x, int y = 6, int z = 8) {
cout << x << endl;
}

//重载
void print(int x, bool ret) {
cout << x << endl;
}

void main() {
print(20);

system("pause");
}

可变参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#define _CRT_SECURE_NO_WARNINGS
#include <stdlib.h>
#include <iostream>
#include <stdarg.h>

//可变参数
//Java可变参数:int...
void func(int i, ...) {
//可变参数指针
va_list args_p;
//开始读取可变参数,i是最后一个固定参数
va_start(args_p, i);
int a = va_arg(args_p, int);
char b = va_arg(args_p, char);
int c = va_arg(args_p, int);
cout << a << endl;
cout << b << endl;
cout << c << endl;
//结束
va_end(args_p);
}

void main() {
func(9, 20, 'b', 30);

system("pause");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
//循环读取可变参数
void func(int i, ...) {
//可变参数指针
va_list args_p;
//开始读取可变参数,i是最后一个固定参数
va_start(args_p, i);
int value;
while (1) {
value = va_arg(args_p, int);
if (value <= 0) {
break;
}
cout << value << endl;
}

//结束
va_end(args_p);
}

void main() {
func(10, 1, 2, 3);

system("pause");
}

C++类

C++类的普遍写法

1
2
3
4
5
6
7
8
9
10
11
#include "MyTeacher.h"

void main() {
MyTeacher t;
t1.name = "Jack";
t1.age = 20;

cout << t.getName() << endl;

system("pause");
}
1
2
3
4
5
6
7
8
9
10
11
12
#pragma once

class MyTeacher {
public:
int age;
char* name;
public:
void setAge(int age);
int getAge();
void setName(char* name);
char* getName();
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include "MyTeacher.h"

void MyTeacher::setAge(int age) {
this->age = age;
}

int MyTeacher::getAge(){
return this->age;
}

void MyTeacher::setName(char* name) {
this->name = name;
}

char* MyTeacher::getName() {
return this->name;
}

构造函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class Teacher {
private:
char *name;
int age;
public:
//无参构造函数(重写无参构造函数,就会覆盖默认的无参构造函数)
Teacher() {
cout << "无参构造函数" << endl;
}

//有参构造函数
Teacher(char *name, int age) {
this->name = name;
this->age = age;
cout << "有参构造函数" << endl;
}
};

void main() {
//Teacher t1;
Teacher t2("Joe", 20);

//另外一种调用方式
Teacher t3 = Teacher("Joe", 20);

system("pause");
}

析构函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
//析构函数
class Teacher {
private:
char *name;
int age;
public:
//无参构造函数赋默认值
Teacher() {
this->name = (char*)malloc(100);
strcpy(name, "AndroidiOS.cc");
age = 20;
cout << "无参构造函数" << endl;
}
//析构函数
//当对象要被系统释放时,析构函数被调用
//作用:善后处理
~Teacher() {
cout << "析构函数" << endl;
//释放内存
free(this->name);
}
};

void func() {
Teacher t; //func函数执行完毕调用析构函数
}

void main(){
func();

system("pause");
}

拷贝构造函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
//拷贝构造函数
class Teacher {
private:
char *name;
int age;
public:
//有参构造函数会覆盖默认的构造函数
Teacher(char *name, int age){
this->name = name;
this->age = age;
cout << "有参构造函数" << endl;
}

//拷贝构造函数(值拷贝)
//默认拷贝构造函数,就是值拷贝
Teacher(const Teacher &obj) {
this->name = obj.name;
this->age = obj.age;
cout << "拷贝构造函数" << endl;
}

void print() {
cout << name << "," << age << endl;
}
};

Teacher func(Teacher t) {
t.print();
return t;
}

void main() {
Teacher t1("Joe", 20);

//拷贝构造函数被调用的场景
//1.声明时赋值
//Teacher t2 = t1;
//t2.print();
//2.作为参数传入,实参给形参赋值
func(t1);
//3.作为函数返回值返回,给变量初始化赋值
//Teacher t3 = func(t1);

//这里不会被调用
//Teacher t1 ;
//Teacher t2;
//t1 = t2;

system("pause");
}

浅拷贝(值拷贝)问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
//浅拷贝(值拷贝)问题
class Teacher {
private:
char *name;
int age;
public:
Teacher(char *name, int age) {
this->name = (char*)malloc(100);
strcpy(this->name, name);
this->age = age;
cout << "有参构造函数" << endl;
}

~Teacher() {
cout << "析构函数" << endl;
//释放内存
free(this->name);
}

void print() {
cout << name << "," << age << endl;
}
};

void func() {
Teacher t1("Joe", 20);

Teacher t2 = t1;
t2.print();
}

void main() {
func();

system("pause");
}

深拷贝

  • 浅拷贝(值拷贝):拷贝的是指针地址
  • 深拷贝:拷贝的是指针指向的堆内存空间数据内容
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
//深拷贝
class Teacher {
private:
char *name;
int age;
public:
Teacher(char *name, int age) {
int len = strlen(name);
this->name = (char*) malloc(len+1);
strcpy(this->name, name);
this->age = age;
cout << "有参构造函数" << endl;
}

~Teacher() {
cout << "析构" << endl;
//释放内存
free(this->name);
}

//深拷贝
Teacher(const Teacher &obj) {
//复制name属性
int len = strlen(obj.name);
this->name = (char*) malloc(len+1);
strcpy(this->name, obj.name);
this->age = obj.age;
}

void print() {
cout << name << "," << age << endl;
}
};

void func() {
Teacher t1("Joe", 20);

Teacher t2 = t1;
t2.print();
}

void main() {
func();

system("pause");
}

Powered by AppBlog.CN     浙ICP备14037229号

Copyright © 2012 - 2020 APP开发技术博客 All Rights Reserved.

访客数 : | 访问量 :