C++学习笔记

1
2
3
4
5
6
7
8

int IsOddNum(int n)  //判断一个数是否是奇数
{
  int flag;
  if(n % 2 == 0) flag = 0;
  else flag = 1;

  return flag;
}

1
2
3
4
5
6
7
8

bool IsOddNum(int n)
{
  bool flag;
  if(n % 2 == 0) flag = true;
  else flag = false;

  return flag;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

#include<iostream>
using namespace std; //使用标准命名空间

int main()
{
    int n;
    float a, b, c;
    cout << "Please enter an integer" << endl; //endl 等价于C语言中的 \n 符号
    cin >> n;
    cout << "The integer you entered is " << n << endl;

    cout << "Please enter three floating point numbers" << endl;
    cin >> a >> b >> c;
    cout << "The three floating point numbers you entered are " << a << ","<< b << "," << c << endl;
    return 0;
}

 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

// myLib.h
#ifndef MYLIB_H
#define MYLIB_H

namespace myLib {
    void log(const std::string& message);
}

#endif // MYLIB_H

// myLib.cpp
namespace myLib {
    void log(const std::string& message) {
        // 实现 myLib 库的日志功能
        std::cout << "MyLib: " << message << std::endl;
    }
}

/* ---------------------------------------分割线--------------------------------------- */

// yourLib.h
#ifndef YOURLIB_H
#define YOURLIB_H

namespace yourLib {
    void log(const std::string& message);
}

#endif // YOURLIB_H

// yourLib.cpp
namespace yourLib {
    void log(const std::string& message) {
        // 实现 yourLib 库的日志功能
        std::cout << "YourLib: " << message << std::endl;
    }
}

1
2
3
4
5
6
7
8

#include "myLib.h"
#include "yourLib.h"

int main() {
    myLib::log("This is a log message from myLib.");
    yourLib::log("This is a log message from yourLib.");
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

#include "myLib.h"
#include "yourLib.h"

using namespace myLib;

int main() {
    log("This is a log message from myLib."); //使用的是myLib的log函数
    yourLib::log("This is a log message from yourLib.");
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

// 格式为：类型 &变量名 = 被引用对象;

#include<iostream>
using namespace std;

int main()
{
    int a = 7;
    int &b = a;
    cout << "a value is: " << a << endl;
    cout << "b value is: " << b << endl;
    cout << "a addr = " << &a << ", b addr = " << &b << "." << endl;
    return 0;
}

/**   运行结果如下：
 *     a value is: 7
 *     b value is: 7
 *     a addr = 0x61fe14, b addr = 0x61fe14.
 */

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

#include<iostream>
using namespace std;

void swap(int &a, int &b);

int main()
{
    int num1 = 10;
    int num2 = 20;
    cout << num1 << " "<< num2 << endl;
    swap(num1, num2);
    cout << num1 << " " << num2 << endl;
    return 0;
}

void swap(int &a, int &b)
{
    int temp = a;
    a = b;
    b = temp;
}

 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

#include<iostream>
using namespace std;

int & valplus1(int &a);
int & valplus2(int c);

int main()
{
    int num1 = 10;
    int num2 = 7;
    int num3;
    num3 = valplus1(num1);  // 能够正确赋值，且不经过临时存储空间
    cout<< num1 << " " << num3 <<endl;

    num3 = valplus2(num2); // 不能正确赋值，因为拷贝数据前存储空间已经被销毁
    cout<< num2 << " " << num3 <<endl;
    return 0;
}

int & valplus1(int &n)
{
    n +=  5;
    return n;
}

int & valplus2(int n)
{
    int t = n + 5;
    return t;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

42;    // 这是 int 型
42u;   // 这是 unsigned int 型
42U;   // 这也是 unsigned int 型
42l;   // 这是 long 型
42L;   // 这也是 long 型
42ll;  // 这是 long long 型
42ul;  // 这是 unsigned long 型
42ull; // 这是 unsigned long long 型
3.14f; // 这是 float 型
1e7L;  // 这是 long double 型
'A'; // 这是 char 型
"abc"; // 这是 string 型
true; // 这是 bool 型
1 + 1; // 这也是常量

// 注：字面量不包括分号;，此处加上分号只为演示作用。
// 字面量（Literal）是指在 C++ 代码中，它的写法能直接体现它所表达的值的常量。

1

const int a = 37;

1
2

cin >> a; // 编译错误：无法向 a 中输入，因为 a 无法发生变化
a = 56;   // 编译错误：无法为 a 赋值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

#include <iostream>
using namespace std;

int main()
{
    int a{0};
    cin >> a;
    const int b{a};
    // b = 42;     // 编译错误
}

1
2
3
4
5
6
7
8
9

#include <iostream>
using namespace std;

int main() {
    const int a{42}; 
    const int b{a};
    const int c{a + b}; 
    // 以上三个只读变量均是常量
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

#include <iostream>
using namespace std;

int main() {
    constexpr int a{42}; // a 是常量（当然常量必然是只读的。）
    int b;               // b 既不是只读变量，也不是常量
    const int c{b};      // c 不是常量，但它是只读变量
 // constexpr int d{b};  // 编译错误，因为要求 d 是常量，但 d 未用常量初始化
    constexpr int e{a};  // OK, e 是常量，由常量初始化
}

 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

// 这里的 const 是底层 const，指针所指向的内容（int类型的值）不能通过 ptr 修改
void func(const int *ptr) 
{ 
    // *ptr = 100; // 错误: 不能通过 const 指针修改值
}

// x 是对一个 const int 的引用，即底层 const
void print(const int &x) 
{ 
    // x = 100; // 错误: 不能修改 const 引用绑定的对象
}

// 这里的 const 是顶层 const，指针的值（一个存储int类型的空间地址）不能修改
void func(int * const ptr) 
{ 
    ......
}

//顶层const，a的值不能被修改
void func(const int a) 
{ 
    ......
}

//左边的const为底层const，右边的const为顶层const
void func(const int * const ptr) 
{ 
    ......
}

 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

// 1. const参数，防止对应实参被修改
void Func(const int &a, const int *b, int c) // 
{
    a = 1; // 错误，不能修改 a 的值
    *b = 2; // 错误，不能修改 *b 的值，但可修改 b 的值
}

// 2. const成员函数（即类中的函数），表明该函数不会修改任何成员变量
// class是定义类的关键字，public和private是定义访问权限的关键字，后面都会详细讲解
class MyClass
{
public:
    void set_value(int value) { _value = value; }

    // get_value()函数不会修改任何成员变量，如果修改了会报错。
    int get_value() const { return _value; }
    
    /**
     *  使用 const 修饰的成员函数就一定要确保其不会修改成员变量。所以，如果一个 const 成员函数调用了另一个
     *  成员函数，也要确保调用的成员函数也是被 const 修饰的。
     *  即const成员函数只能调用其他const成员函数，否则会报错。
     *  例如，如果 get_value() 函数不是const成员函数，那么 show() 是不能调用它的，强行调用是不能通过编译的。
     */
    void show() const { cout << get_value() << endl; }
private:
    int _value;
};

// 3.const返回值，防止调用者通过返回的引用或指针修改原始对象。
const MyClass& getConstObject() const 
{
    return obj;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

#include <iostream>
using namespace std;

void Func(int a, int b, int c = 1) // Func函数的形参c就有默认参数1
{
    cout << a << " " << b << " " << c << endl;
}

int main()
{
    Func(1, 2, 3); // 正确调用，输出 1 2 3
    Func(1, 2); // 正确调用，输出 1 2 1

    return 0;
}

1
2
3
4
5
6

// 错误定义，如果b要定义默认参数，则c也要定义默认参数
int Func(int a, int b = 1, int c) 
{
    ......
    return a;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#include <iostream>
using namespace std;

// 以下 print 函数形成重载
void print(const char *str, int width); // 声明 #1
void print(double d, int width);    // 声明 #2
void print(long l, int width);  // 声明 #3
void print(int i, int width);   // 声明 #4
void print(const char *str);    // 声明 #5

int main()
{
    print("Pancakes", 15);  // 调用第1个print
    print(1999.0, 10);  // 调用第2个print
    print(1999L, 15);   // 调用第3个print
    print(1999, 12);    // 调用第4个print
    print("syrup"); // 调用第5个print

    return 0;
}

// 5个print函数的具体实现省略
....

 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

// 遍历数组
int array[] = {1, 2, 3, 4, 5};
for (int num : array) {
    std::cout << num << " ";
}
// 输出：1 2 3 4 5

/* ---------------------------------分割线--------------------------------- */

// 遍历 std::vector
#include <vector>
#include <string>
#include <iostream>

std::vector<std::string> vec = {"Apple", "Banana", "Cherry"};
for (const std::string& fruit : vec) {
    std::cout << fruit << " ";
}
// 输出：Apple Banana Cherry

/* ---------------------------------分割线--------------------------------- */

// 遍历字符串
std::string str = "Hello";
for (char c : str) {
    std::cout << c << " ";
}
// 输出：H e l l o

/* ---------------------------------分割线--------------------------------- */

// 修改数组中的值
int array[] = {1, 2, 3, 4, 5};
for (int &num : array) {
    num++;
}
// 数组中的值变为：2 3 4 5 6

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

inline void swap(int &a, int &b);  // 将 inline 放在函数声明处不会起作用
void swap(int &a, int &b)
{
    int temp = a;
    a = b;
    b = temp;
}

/* ---------------------------------分割线--------------------------------- */

void swap(int &a, int &b);
inline void swap(int &a, int &b) // 成功将 swap 函数声明为内联函数
{
    int temp = a;
    a = b;
    b = temp;
}

1
2
3
4
5

int *p = new int; // 申请了一个int类型的空间，等价于 malloc(sizeof(int));
int *A = new int[10]; // 申请了一个数组空间，大小为10，用于存在int类型的值，等价于 malloc(sizeof(int) * 10);

delete p; // 释放单个的空间
delete[] A; //释放数组空间

 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

// 基本数据类型转换
int i = 10;
float f = static_cast<float>(i);  // 将int转换为float

/* ---------------------------------分割线--------------------------------- */

// 指针类型转换
// 对于基本数据类型的指针 static_cast 不能在两个「具体类型」的指针之间进行转换，只能
// 将一个指针转换为 void * 类型，或将 void * 类型的指针转换为其原本的数据类型
int i = 5;
void* ptr = static_cast<void *>(&i); // 将 int * 类型的指针转换为 void * 类型
int* intPtr = static_cast<int*>(ptr); // void指针转换回int指针
// float *floatPtr = static_cast<float*>(&i)  // 这种转换是不被允许的

class Base {};
class Derived : public Base {};
Derived d;
Base* basePtr = static_cast<Base*>(&d); // 派生类指针转换为基类指针

/* ---------------------------------分割线--------------------------------- */

// 类型向上的安全类型转换。
// 了解即可，后面会介绍类的相关知识
class Base {
public:
    virtual ~Base() {}
};

class Derived : public Base {
public:
    void func() {
        // ...
    }
};

void function(Base& baseRef) {
    Derived& derivedRef = static_cast<Derived&>(baseRef); //将派生类 Derived 类型的引用转换为基类Base类型的引用
    derivedRef.func(); // 使用 Derived 类型的引用调用 Derived 的成员函数
}

 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

class Base {
public:
    virtual ~Base() {} // 虚析构函数，确保类是多态的
};

class Derived : public Base {
    // 派生类内容
};

int main() {
    Derived d;
    Base* b = &d;

    // 向下转型尝试
    Derived* d2 = dynamic_cast<Derived*>(b);
    if (d2) {
        // 转换成功，d2 是一个 Derived 类型的指针
    } else {
        // 转换失败，这在本例中不会发生，因为 b 确实指向 Derived 对象
    }

    // 错误的向下转型尝试
    Base b2;
    Derived* d3 = dynamic_cast<Derived*>(&b2);
    if (!d3) {
        // 转换失败，b2 是 Base 类型的实例，而不是 Derived
    }

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

#include<iostream>
using namespace std;

int main()
{
    const int a = 10;
    const int * p = &a;
    int *q;
    q = const_cast<int *>(p);
    *q = 20;    //fine
    cout << a << " " << *p << " " << *q << endl;
    cout << &a << " " << p << " " << q <<endl;
    return 0;
}

1
2

10 20 20
002CFAF4 002CFAF4 002CFAF4

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

    // 将整型指针转换为双精度浮点型指针
    int *a = new int;
    double *d = reinterpret_cast<double *>(a);

    int i = 100;
    int* p = &i;

    cout << "p value: " << p << endl;
    // 将整数地址转换为整数
    intptr_t address_as_int = reinterpret_cast<intptr_t>(p);
    cout << "address_as_int: " << address_as_int << endl ;

    // 将整数重新转换回指针
    int* p2 = reinterpret_cast<int*>(address_as_int);
    cout << "p2 value: " << p2 << endl;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

try
{
    //可能抛出异常的语句
}
catch (异常类型1)
{
    //异常类型1的处理程序
}
catch (异常类型2)
{
    //异常类型2的处理程序
}
// ……
catch (异常类型n)
{
    //异常类型n的处理程序
}

 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

#include<iostream>
using namespace std;

enum index{underflow, overflow};

int array_index(int *A, int n, int index);

int main()
{
    int *A = new int[10];
    for(int i=0; i < 10;  i++) A[i] = i;

    try
    {
        cout<<array_index(A,10,5)<<endl;
        cout<<array_index(A,10,-1)<<endl;
        cout<<array_index(A,10,15)<<endl;
    }
    catch(index e)
    {
        if(e == underflow)
        {
            cout<<"index underflow!"<<endl;
            exit(-1);
        }
        if(e == overflow)
        {
            cout<<"index overflow!"<<endl;
            exit(-1);
        }
    }

    return 0;
}

int array_index(int *A, int n, int index)
{
    if(index < 0) throw underflow;  // 抛出下溢出异常
    if(index > n-1) throw overflow; // 抛出上溢出异常
    return A[index];
}

1
2

string s = "mystring";
int len = s.length();  // len 的值为 8

 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

#include <iostream>
#include <string>
using namespace std;

int main()
{
    char c_char_array[] = "Hello, World!";

    //  只定义不初始化，编译器会使用默认值（空字符串）进行赋值
    string s1;

    // 定义时直接进行初始化
    string s2 = "mystring";

    // 定义时进行复制初始化，s3的内容和s2一样
    string s3 = s2;

    // 定义时使用指定字符和大小来初始化，s4 的内容为 sssssss
    string s4 (7, 's');

    // 定义时使用字符数组来进行初始化，s5的内容为 Hello, World!
    string s5(c_char_array);

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

#include <iostream>
#include <string>

int main() 
{
    std::string str = "Hello, World!";
    const char* cstr = str.c_str();  // 进行转换
    std::cout << cstr << std::endl; // 输出: Hello, World!
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// C风格的字符串
char info[100];

cin >> info; //第一种
cin.getline(info, 100); // 第二种，读取一行，会抛弃最后的 '\n'
cin.get(info, 100); // 第三种，读取一行，保留最后的 '\n'

/* ---------------------------------分割线--------------------------------- */

// string对象
string str;

cin >> str; //第一种，读取一个单词，即遇到 空格或换行符就结束读取
getline(cin, str); //第二种，读取一行，即遇到 '\n' 结束读取

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

#include<iostream>
#include<string>
using namespace std;

int main()
{
    string mystr;
    getline(cin, mystr);

    cout << mystr << endl; //进行输出
    return 0;
}

 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

#include <iostream>
#include <string>

using namespace std;

int main()
{
    string s1, s2, s3;
    s1 = "first";
    s2 = "second";
    
    s3 = s1 + s2;
    cout<< s3 <<endl; // 输出：firstsecond

    s2 += s1;
    cout<< s2 <<endl;  // 输出：secondfirst
    
    s1 += "third";
    cout<< s1 <<endl; //输出：firstthird
    
    s1 += 'a';
    cout<< s1 <<endl; //输出：firstthirda
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <iostream>
#include <string>

using namespace std;

int main()
{
    string s = "1234567890";

    for(int i = 0; i < s.length(); i++) // 遍历字符串中的每个字符
    {
        cout<< s[i] <<" ";
    }
    // for循环的最终输出结果为 1 2 3 4 5 6 7 8 9 0

    cout << endl; // 输出换行符

    s[7] = '9';
    cout << s << endl; // 输出结果为1234567990

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

#include <iostream>
#include <string>

using namespace std;

int main()
{
    string s1, s2, s3;
    s1 = s2 = s3 = "1234567890";
   
    s2.erase(5);
    s3.erase(5, 3);
   
    cout << s1 << endl; // 输出 1234567890
    cout << s2 << endl; // 输出 12345
    cout << s3 << endl; // 输出  1234590
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#include <iostream>
#include <string>

using namespace std;

int main()
{
    char carry[] = "bbb";

    string s1, s2;
    s1 = "1234567890";
    s2 = "aaa";

    cout << s1 << endl; // 输出 1234567890

    s1.insert(5, s2);
    cout << s1 << endl; // 输出 12345aaa67890

    s1.insert(5, carry);
    cout << s1 << endl; // 12345bbbaaa67890

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

#include <iostream>
#include <string>

using namespace std;

int main()
{
    string s1, s2, s3;
    s1 = s2 = "1234567890";
    s3 = "aaa";

    cout << s1 << endl; // 输出 1234567890
    s1.replace(5, 4, s3);
    cout << s1 << endl; // 输出 12345aaa0

    cout << s2 << endl; // 输出 1234567890
    s2.replace(5, 2, "aaa");
    cout<< s2 <<endl; // 输出 12345aaa890
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

#include <iostream>
#include <string>

using namespace std;

int main()
{
    string s1 = "string";
    string s2 = "aaaaaa";
   
    s1.swap(s2); // 互换值
    
    cout << s1 << endl; // 输出 aaaaaa
    cout << s2 << endl; // 输出 string
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

#include <iostream>
#include <string>
using namespace std;

int main()
{
    string s1 = "first second third";
    string s2, s3;

    s2 = s1.substr(6, 6);
    s3 = s1.substr(6);

    cout << s2 << endl; // 输出second
    cout << s3 << endl; // 输出second third

    return 0;
}

 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

#include <iostream>
#include <string>
using namespace std;

int main()
{
    string s1 = "first second third";
    string s2 = "second";

    int index1 = s1.find(s2, 6);
    int index2 = s1.find(s2, 7);

    // 输出 Found at index : 6
    if(index1 != std::string::npos)
        cout<<"Found at index : "<< index1 <<endl;
    else
        cout<<"Not found"<<endl;
    
    // 输出 Not found
    if(index2 != std::string::npos)
        cout<<"Found at index : "<< index2 <<endl;
    else
        cout<<"Not found"<<endl;

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

#include <iostream>
#include <string>
using namespace std;

int main()
{
    string s1 = "secondsecondthird";
    string s2 = "secondthird";
    
    if( s1 == s2 ) cout << " == " << endl;
    if( s1 != s2 ) cout << " != " << endl;
    if( s1 < s2 ) cout << " < " << endl;
    if( s1 > s2 ) cout << " > " << endl;

    return 0;
}
// 最终输出 != 和 <

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

class Student
{
    // 在这里定义成员变量和成员函数
};

int main()
{
    Student xiao_ming; // 定义了一个 Student类型的对象 xiao_ming
    Student all_student[1000]; // 定义了一个Student类型的数组，大小为1000
    Student *stuptr; // 定义了一个Student类型的指针
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

class Student
{
    // 定义对应的成员变量
    string _name;
    int _id_num;
    int _age;
    char _sex;

    // 定义对应的成员函数
    void set_age(int age);
    int get_age();
};

 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

class Student
{
    // 定义对应的成员变量
    string _name;
    int _id_num;
    int _age;
    char _sex;

    // 使用内联定义
    void set_age(int age) { _age = age; }
    int get_age() const { return _age; }  //这里的const表示该函数只会读取变量值，不会修改变量值，如果修改了变量值编译器会报错。
};

/* ---------------------------------分割线--------------------------------- */

// 在头文件 example.h 中给出类定义
class Student
{
    // 定义对应的成员变量
    string _name;
    int _id_num;
    int _age;
    char _sex;

    // 只声明成员函数
    void set_age(int age);
    int get_age() const;
};

// 在对应的 example.cpp 文件给出成员函数的定义
void Student::set_age(int age)  // 需要使用 类名+域解析符:: 告诉编译器这是哪个类的成员函数
{
    _age = age;
}

int Student::get_age() const
{
    return _age;
}

 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

#include <iostream>
#include <string>
using namespace std;

class Student
{
    string _name;
    int _id_num;
    int _age;
    char _sex;
public:
    void set_age(int age) { _age = age; }
    int get_age() const { return _age; }
};

int main()
{
    Student xiao_ming;
    Student *xiao_li_ptr = new Student;

    xiao_ming.set_age(20);
    cout << xiao_ming.get_age() << endl;

    xiao_li_ptr->set_age(22);
    cout << xiao_li_ptr->get_age() << endl;
    return 0;
}

 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
51
52
53
54
55
56
57

#include <iostream>
using namespace std;

//类的声明
class Student
{
private:
    // 私有成员，只能被该类的其他成员访问
    string _name;
    int _age;
    float _score;

public:
    // 公有成员
    void set_name(const string &name);
    void set_age(const int age);
    void set_score(const float score);
    void showInfo() const;
};

// 成员函数的定义
void Student::set_name(const string &name)
{
    _name = name;
}

void Student::set_age(const int age)
{
    _age = age;
}

void Student::set_score(const float score)
{
    _score = score;
}

void Student::showInfo() const
{
    cout << _name << "的年龄是" << _age << "，成绩是" << _score << endl;
}

int main()
{
    Student stu;
    stu.set_name("小明");
    stu.set_age(15);
    stu.set_score(92.5f);
    stu.showInfo();

    Student *pstu = new Student;
    pstu -> set_name("李华");
    pstu -> set_age(16);
    pstu -> set_score(96);
    pstu -> showInfo();

    return 0;
}

 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
51
52

#include <iostream>
using namespace std;

class Student
{
private:
    string _name;
    int _age;
    float _score;

public:
    void set_name(const string &name);
    void set_age(const int age);
    void set_score(const float score);

    string get_name()const {return _name;}
    int get_age()const {return _age;}
    float get_score()const {return _score;}
};

void Student::set_name(const string &name)
{
    _name = name;
}

void Student::set_age(const int age)
{
    _age = age;
}

void Student::set_score(const float score)
{
    _score = score;
}

const Student& show(const Student &mstu) // 使用引用来传递和返回对象
{
    cout << mstu.get_name() << "的年龄是" << mstu.get_age() << "，成绩是" << mstu.get_score() << endl;
    return mstu;
}

int main()
{
    Student stu;
    stu.set_name("小明");
    stu.set_age(15);
    stu.set_score(92.5f);

    const Student &t_stu = show(stu);
    cout << t_stu.get_name() << endl; // 输出小明
    return 0;
}

 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

#include <iostream>
using namespace std;

class Student
{
private:
    string _name;
    int _age;
    float _score;

public:
    Student(const string &name, int age, float score);

    string get_name()const {return _name;}
    int get_age()const {return _age;}
    float get_score()const {return _score;}
    void showInfo() const;
};

Student::Student(const string &name, int age, float score)
{
    _name = name;
    _age = age;
    _score = score;
}

void Student::showInfo() const
{
    cout << _name << "的年龄是" << _age << "，成绩是" << _score << endl;
}

int main()
{
    Student stu("小明", 15, 92.5f); // 隐式调用对应的构造函数完成初始化

    // Student stu1;   // 该代码是错误的，因为没有匹配的构造函数
    stu.showInfo();
    return 0;
}