关键点
- 構造体可以通过它创建“将多个类型汇总的新类型”
- 构造体定义
struct 構造体名 {
型1 メンバ変数名1
型2 メンバ変数名2
型3 メンバ変数名3
...(必要な分だけ書く)
}; // ← セミコロンが必要
- 结构体变量的声明
構造体名 変数名;
- 结构体类型的值被称为对象叫做
- 声明的同时进行初始化
構造体名 オブジェクト名 = {メンバ変数1の値, メンバ変数2の値, メンバ変数3の値, ...(必要な分だけ書く)};
- 成员变量、menba关数可以分别作为绑定到对象的变量、关系数使用
- 访问成员变量
オブジェクト.メンバ変数
- 成员函数的定义
struct 構造体名 {
返り値の型 メンバ関数名(引数の型1 引数名1, 引数の型2 引数名2, ...) {
// 関数の内容
// (ここではメンバ変数に直接アクセスすることができる)
}
};
- 成员函数的调用
オブジェクト.メンバ関数(引数1, 引数2, ...)
構造体
「3.02.pair/tupletoauto介绍了使用“”将多个数据汇总的方法作为STL的pair/tuple。另一种方法構造体也可以使用。实际上STL的pair/tuple也是使用结构体实现的。
由于结构体相关的功能很多,所以在本页中将简单说明主要的内容。
通过使用结构体,可以定义“将多个类型组合在一起的新类型”。
请看以下程序。
#include <bits/stdc++.h>
using namespace std;
struct MyPair {
int x; // 1つ目のデータはint型であり、xという名前でアクセスできる
string y; // 2つ目のデータはstring型であり、yという名前でアクセスできる
};
int main() {
MyPair p = {12345, "hello"}; // MyPair型の値を宣言
cout << "p.x = " << p.x << endl;
cout << "p.y = " << p.y << endl;
}
実行結果
p.x = 12345 p.y = hello
MyPair定义了一个名为的结构体。这个结构体将int类型和字符串类型组合在一起,它们分别具有x, y的名称。
每一个这样的数据称为成员变量。
构造体定义
结构体可以通过以下形式来定义。
struct 構造体名 {
型1 メンバ変数名1
型2 メンバ変数名2
型3 メンバ変数名3
...(必要な分だけ書く)
}; // ← セミコロンが必要
结构体的定义可以写在函数复习或中期考试的内容中。
定义结构体后,就可以使用新的类型。例如,在上面的例子中,MyPair定义了一个结构体,从此以后可以使用MyPair这一类型。
声明、初始化
要声明结构体变量,像声明普通变量一样写如下。
構造体名 変数名;
另外,也可以像下面这样使用结构体名生成结构体的值。
auto 変数名 = 構造体名();
使用结构体名的方法在需要临时变量的场合很方便。
另外,结构体类型的值被称为对象。
例如,在第一个示例程序中
p为MyPair类型的对象。
如果要在声明成员变量的同时对其进行初始化,请执行以下操作:
構造体名 オブジェクト名 = {メンバ変数1の値, メンバ変数2の値, メンバ変数3の値, ...(必要な分だけ書く)};
成员变量
结构体保存的变量成员变量。
按如下方式访问成员变量。
オブジェクト.メンバ変数
成员变量可以像常规变量一样使用。
请注意,与普通变量一样,仅通过声明对象来定义成员变量的值。
menba关数
结构可以定义执行与对象相关的操作的函数。menba关数。
成员函数定义如下。
struct 構造体名 {
返り値の型 メンバ関数名(引数の型1 引数名1, 引数の型2 引数名2, ...) {
// 関数の内容
// (ここではメンバ変数に直接アクセスすることができる)
}
};
调用成员函数:
オブジェクト.メンバ関数(引数1, 引数2, ...)
成员函数的一个特点是,当从函数内部访问“成员函数关联的对象的成员变量”时,可以直接访问它们,而无需指定对象。 除此之外,您可以像使用其他功能一样使用它。
使用成员访问函数时,成员函数和常规函数之间存在差异。 在APG4b处理的范围内,它们基本上可以像普通函数一样使用。
请检查以下示例程序。
示例程序
#include <bits/stdc++.h>
using namespace std;
struct MyPair {
int x;
string y;
// メンバ関数
void print() {
// 直接x, yにアクセスできる
cout << "x = " << x << endl;
cout << "y = " << y << endl;
}
};
int main() {
MyPair p = { 12345, "Hello" };
p.print(); // オブジェクト`p`の`print`を呼び出す
MyPair q = { 67890, "APG4b" };
q.print(); // オブジェクト`q`の`print`を呼び出す
}
実行結果
x = 12345 y = Hello x = 67890 y = APG4b
详情
构造函数
如果你想在创建对象时执行自己的初始化处理, 您可以使用构造函数。
构造函数定义如下。
struct 構造体名 {
// コンストラクタ
構造体名() {
// コンストラクタの内容
}
};
示例程序
#include <bits/stdc++.h>
using namespace std;
struct MyPair {
int x;
string y;
// コンストラクタ
MyPair() {
cout << "constructor called" << endl;
}
};
int main() {
MyPair p; // ここでコンストラクタが呼ばれる
p.x = 12345;
p.y = "hello";
cout << "p.x = " << p.x << endl;
cout << "p.y = " << p.y << endl;
}
実行結果
constructor called p.x = 12345 p.y = hello
构造函数可以像成员函数一样接受参数。
struct 構造体名 {
// コンストラクタ
構造体名(引数1の型 引数1の名前, 引数2の型 引数2の名前, ...) {
// コンストラクタの内容
}
};
如果构造函数带参数,则在声明对象时必须传递构造函数参数对应的值,如下:
構造体名 オブジェクト名(引数1, 引数2, 引数3, ...);
示例程序
#include <bits/stdc++.h>
using namespace std;
struct NumString {
int length;
string s;
// コンストラクタ
NumString(int num) {
cout << "constructor called" << endl;
// 引数のnumを文字列化したものをsに代入し、sの文字数をlengthに代入する
s = to_string(num); // (STLの関数)
length = s.size();
}
};
int main() {
NumString num(12345); // コンストラクタに 12345 が渡される
cout << "num.s = " << num.s << endl;
cout << "num.length = " << num.length << endl;
}
実行結果
constructor called num.s = 12345 num.length = 5
可以定义多个构造函数,并且可以根据提供的参数的类型和数量自动调用它们。
#include <bits/stdc++.h>
using namespace std;
struct MyPair {
int x;
string y;
// コンストラクタ1
MyPair() {
cout << "初期化無し" << endl;
}
// コンストラクタ2
MyPair(int x_) {
cout << "xのみ初期化" << endl;
x = x_;
}
// コンストラクタ3
MyPair(int x_, string y_) {
cout << "x, y両方初期化" << endl;
x = x_;
y = y_;
}
};
int main() {
MyPair p; // コンストラクタ1が呼ばれる
cout << "p.x = " << p.x << endl;
cout << "p.y = " << p.y << endl;
MyPair q(6789); // コンストラクタ2が呼ばれる
cout << "q.x = " << q.x << endl;
cout << "q.y = " << q.y << endl;
MyPair r(11111, "good bye"); // コンストラクタ3が呼ばれる
cout << "r.x = " << r.x << endl;
cout << "r.y = " << r.y << endl;
}
実行結果(例)
初期化無し p.x = 4198608 p.y = xのみ初期化 q.x = 6789 q.y = x, y両方初期化 r.x = 11111 r.y = good bye
此外,
当使用{}初始化对象时,相应的构造函数参数是
必须包含在{}中。
構造体名 オブジェクト名 = {引数1, 引数2, 引数3, ...};
使用构造函数参数而不是成员变量。
请注意,它包含在{}中。
复制构造函数
创建对象时调用构造函数, 如果满足条件,例如将对象作为函数参数传递时, 调用一个名为复制构造函数的特殊构造函数。
复制构造函数在以下情况下被调用:
- 将对象作为函数参数传递时
- 声明对象时
使用
MyStruct new_obj = old_obj;初始化时 以 - 声明对象时
使用
MyStruct new_obj(old_obj);形式初始化时 - 等
关于复制构造函数有很多复杂的故事,所以我只介绍基础知识。
复制构造函数定义如下。
struct 構造体名 {
// コピーコンストラクタ
構造体名(const 構造体名 &old) {
// コンストラクタの内容
// (oldの内容を使って初期化などを行う)
}
};
const 是一个无法重写变量内容的函数。在这个例子中, 无法再重写
old的成员变量。 详细信息将在 3.07 中介绍。
参数名称old,但您可以随意命名。
如果没有定义复制构造函数, “通过按原样复制所有成员变量来创建一个新对象” 一个像这样工作的复制构造函数自动创建所以, 如果只是想复制,则不需要自己编写复制构造函数。
请注意,由于编译器优化,复制构造函数调用可能会被省略。
示例程序
#include <bits/stdc++.h>
using namespace std;
struct MyPair {
int x;
string y;
// コンストラクタ
MyPair() {
cout << "normal constructor called" << endl;
}
// コピーコンストラクタ
MyPair(const MyPair &old) {
cout << "copy constructor called" << endl;
x = old.x + 1;
y = old.y + " new";
}
};
int main() {
MyPair p; // ここでコンストラクタが呼ばれる
p.x = 12345;
p.y = "hello";
cout << "p.x = " << p.x << endl;
cout << "p.y = " << p.y << endl;
MyPair q(p); // コピーコンストラクタが呼ばれる
cout << "q.x = " << q.x << endl;
cout << "q.y = " << q.y << endl;
MyPair r = q; // コピーコンストラクタが呼ばれる
cout << "r.x = " << r.x << endl;
cout << "r.y = " << r.y << endl;
}
実行結果
normal constructor called p.x = 12345 p.y = hello copy constructor called q.x = 12346 q.y = hello new copy constructor called r.x = 12347 r.y = hello new new
您还可以同时定义普通构造函数和复制构造函数,如本示例程序所示。
运算符重载
您可以在新定义的结构类型对象上使用 C++ 运算符,并且此功能运算符重载。
尽管可以重载的运算符数量有限,但大多数运算符都可以重载。
虽然使用运算符重载可以简化程序,但请注意,它也会使含义更难以理解。
在一个极端的例子中, 尽管可以让运算符
+执行减法,但应尽可能避免这种不平凡的行为。
+ 运算符重载
示例程序
#include <bits/stdc++.h>
using namespace std;
struct MyPair {
int x;
string y;
// 別のMyPair型のオブジェクトをとって、x, yにそれぞれ+したものを返す
// +演算子をオーバーロード
MyPair operator+(const MyPair &other) {
MyPair ret;
ret.x = x + other.x; // ここではint型の+演算子が呼ばれる
ret.y = y + other.y; // ここではstring型の+演算子が呼ばれる
return ret;
}
};
int main() {
MyPair a = {123, "hello"};
MyPair b = {456, "world"};
// MyPair型の+演算子が呼ばれる
MyPair c = a + b;
cout << "c.x = " << c.x << endl;
cout << "c.y = " << c.y << endl;
}
実行結果
c.x = 579 c.y = helloworld
运算符重载被定义为成员函数。 要重载
+运算符,请按如下方式定义它。
struct 構造体名 {
返り値の型 operator+(引数の型 引数) {
// 処理内容
}
};
您可以自由决定返回值和参数类型。然而,参数的数量是一个。
+运算符重载也可以在结构体外部定义。
这将在下面的“定义外部时”中解释。
赋值运算符重载
=运算符(赋值运算符)的行为可以通过重载来自定义,就像其他运算符一样。
如果不重载,则会自动定义赋值运算符。 自动定义的赋值运算符执行“按原样分配所有成员变量”等处理。
示例程序
#include <bits/stdc++.h>
using namespace std;
struct MyPair {
int x;
string y;
// 代入演算子をオーバーロード
void operator=(const MyPair &other) {
cout << "= operator called" << endl;
x = other.x;
y = other.y;
}
};
int main() {
MyPair a = {123, "hello"};
MyPair b;
b = a; // 代入演算子が呼ばれる
cout << "b.x = " << b.x << endl;
cout << "b.y = " << b.y << endl;
}
実行結果
= operator called b.x = 123 b.y = hello
赋值运算符的重载定义如下:
void operator=(const 構造体名 &other) {
// 処理内容
}
其他运算符重载
其他运算符也可以重载。 将运算符重载定义为成员函数时:
struct 構造体の型 {
返り値の型 operator演算子(引数の型 引数) {
// 処理内容
}
};
在“操作符”部分,
写一些类似+, -, *, /, %, <, >, ==, !=, &&, ||的内容。
当在外部定义时
结构体外部的运算符重载导致
您尚未定义的结构(例如,STL
您还可以重载pair等运算符。)
如果要在结构体外部定义运算符重载,请执行以下操作:
返り値の型 operator演算子(引数の型1 引数1, 引数の型2 引数2) {
// 処理内容
}
以下是
这是pair<int, int>运算符重载的示例程序。
对
对于反对+重载运算符示例
+重载运算符示例#include <bits/stdc++.h>
using namespace std;
pair<int, int> operator+(pair<int, int> a, pair<int, int> b) {
pair<int, int> ret;
ret.first = a.first + b.first;
ret.second = a.second + b.second;
return ret;
}
int main() {
pair<int, int> a = {1, 2};
pair<int, int> b = {3, 4};
auto c = a + b;
cout << c.first << ", " << c.second << endl; // 4, 6
}
実行結果
4, 6
对
对于的<通过重载运算符
更改比较以确定优先级的示例.second更改为优先比较的示例
<通过重载运算符
更改比较以确定优先级的示例.second更改为优先比较的示例#include <bits/stdc++.h>
using namespace std;
// .second → .first の順に比較
bool operator<(pair<int, int> l, pair<int, int> r) {
if (l.second != r.second) {
return l.second < r.second;
} else {
return l.first < r.first;
}
}
// <演算子 を用いて定義
bool operator> (pair<int, int> l, pair<int, int> r) { return r < l; }
bool operator<=(pair<int, int> l, pair<int, int> r) { return !(r < l); }
bool operator>=(pair<int, int> l, pair<int, int> r) { return !(l < r); }
int main() {
pair<int, int> a = {1, 5};
pair<int, int> b = {3, 2};
cout << (a < b) << endl; // 0
cout << (a > b) << endl; // 1
}
実行結果
0 1std::pair 的非成员运算符重载被定义为模板函数,因此 `bool operator<(pair<int, int> l,pair<int, int> r)` 被称为 std::pair<int, int> 的特化
请注意,复合赋值运算符 (
请注意,+=, -=, *=, /=, %=等)不能在结构体外部定义。
用作STL容器元素时的注意事项
STL 容器和函数可能需要特定的运算符。
比较运算符
您需要重载<。
当使用结构体作为
map的键时 使用结构体作为priority_queue的元素类型时- 对于结构体数组
sort使用功能时
比較演算子<定义如下。
bool operator<(const 構造体名 &left, const 構造体名 &right) {
// left < right の場合に true を返すように実装する
}
成员初始值设定项列表
作为初始化成员变量的一种方式, 有一种方法可以使用成员初始值设定项列表。
基本上与构造函数中的赋值相同,但是 例如,如果成员变量是引用类型并且不能在构造函数中初始化, 必须使用成员初始值设定项列表进行初始化。
示例程序
#include <bits/stdc++.h>
using namespace std;
struct MyPair {
int x;
string y;
// 初期化子リストを用いた初期化
MyPair() : x(123), y("hello") {
}
};
int main() {
MyPair p; // コンストラクタにより初期化される
cout << "p.x = " << p.x << endl;
cout << "p.y = " << p.y << endl;
}
実行結果
p.x = 123 p.y = hello
成员初始值设定项列表位于构造函数中,如下所示:
继续写入:。
struct 構造体名 {
型1 メンバ変数1;
型2 メンバ変数2;
...(必要な分だけ書く)
構造体名() : メンバ変数名1(初期化内容), メンバ変数名2(初期化内容), ...(必要な分だけ書く)
{
}
};
在初始化部分,
您也可以将其写为メンバ変数名{初期化内容1, 初期化内容2, ...}。
类
C++ 具有与结构体几乎相同的功能。类。
类和结构之间的区别是成员访问的默认行为。 APG4b不处理成员访问,但它是一个限制成员变量和成员函数可以使用范围的函数。 可以创建“只能在成员函数内处理的成员变量”和“只能在成员函数内调用的成员函数”。
默认成员访问权限是私有成员访问权限(
private:),并且结构具有公共成员访问权限(指定时的行为public:时的行为)。
类(结构)有 还有一个名为継承的函数。 面向对象编程有各种有用的功能可用。 如果您有兴趣,请查看一下。
未涵盖的结构相关函数列表
以下是无法在此页面上引入的功能列表。 如果您想了解更多信息,请查看。
- 析构函数
- 会员访问
- 継承
- 静态成员变量/函数
- 朋友宣言
- 联盟
- 位字段
- 等
演習問題
请解决链接目的地的问题。