C++信息3笔记-1

记载C++的学习笔记

开始

1
2
3
4
5
6
7
8
#include <iostream>
using iostream std;

int main (void)
{
	cout << "nihao" << endl;
	return 0;
}

这里要区分的是”\n”和endl的区别，实际上endl就是”\n”+fflush()，也就是说endl还会对于刷新缓冲区。

基本概念

  1. 命令空间（namespace)，在协同开发的时候，为了防止不同的程序员设置了不相同的对象\函数名称，所以引入了命令空间的概念。实际上就相当于是一个个的命令块。想要使用string、cin cout等等对象 ,则需要将std包裹进来.

  2. :: 叫作用域区分符，指明一个函数属于哪个类或一个数据属于哪个类。:: 可以不跟类名，表示全局数据或全局函数（即非成员函数）。
    例如:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    int month;//全局变量
    int day;
    int year;
    void Set(int m,int d,int y)
    {
        ::year=y; //给全局变量赋值，此处可省略
        ::day=d;
        ::month=m;
    }

    Class Tdate
    {
        public:
            void Set(int m,int d,int y) //成员函数
            {
                ::Set(m,d,y); //非成员函数
            }
        private:
            int month;
            int day;
            int year;
    }

  3. 关于C++中的inline关键字. 这个关键字只有用在函数的定义前才有用, 放在函数的声明前无法保证这个函数是内联函数.

初始化方法

在c++中支持两种初始化方式：

  • 拷贝初始化
  • 直接初始化
    1
    2
    A x(2);　　//直接初始化，调用构造函数
    A y = x;　　//拷贝初始化，调用拷贝构造函数

类访问修饰符

在C++中有三种类访问修饰符:

  • public公共的
  • private私有的
  • protected受保护的

一个类可以有多个 public、protected 或 private 标记区域。每个标记区域在下一个标记区域开始之前或者在遇到类主体结束右括号之前都是有效的。成员和类的默认访问修饰符是 private。

public

这个没什么好讲的, 就是都可以访问

private

私有成员变量或函数在类的外部是不可访问的，甚至是不可查看的。只有类和友元函数可以访问私有成员。

实际操作中，我们一般会在私有区域定义数据，在公有区域定义相关的函数，以便在类的外部也可以调用这些函数

修改私有变量的方法:

  • 通过友元函数
  • 通过类中的函数, 尽管这个函数是公共的而数据是私有的. 将函数定义为public, 将数据定义为private. 使用这个函数来更改数据是正确的.
  • 使用指针访问私有变量:
    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;

    class a    // 定义了类a
    {
        long a0;   // 定义私有成员 a0
        public:
        a(long b)
        {
            a0=b;
        }
        void geta()
        {
            cout<<a0<<endl;
        }
    };
    int main()
    {
        a b(5);          // 定义对象b，并给 b 中的 a0 赋初值
        long *p;
        p=(long*)&b;     // 令指针 p 指向 b 中前 4 个字节，在这里相当于指向 a0
        b.geta();        // 用内部函数访问 a0
        cout<<*p<<endl;  // 在外部直接访问 a0
        *p=8;            // 在外部改变 a0 的值
        b.geta();        // 输出改变后的结果
        cout<<*p<<endl;
        return 0;
    }

    //需要注意的是，使用这种方法虽然可以用于基于类的多态原则的一些程序开发，但违反了类的封装原则，在使用指针的类中也极不安全，所以不建议使用。

protected

受保护类型的成员对象或者是函数, 和私有类型非常相似. 但有一点不同，protected（受保护）成员在派生类（即子类）中是可访问的。注意, 这个子类可访问是只可以在这个子类中使用, 出了这个子类就无法使用了.

子类的三种继承

例子如下:

初始化列表

在类的初始化中, 还可以使用C++提供的初始化列表来进行初始化:

1
2
3
4
C::C( double a, double b, double c): X(a), Y(b), Z(c)
{
  ....
}//假设有一个类 C，具有多个字段 X、Y、Z 等需要进行初始化，同理地，您可以使用上面的语法，只需要在不同的字段使用逗号进行分隔

使用初始化列表来初始化的时候, 初始化的顺序是按照类中的声明顺序来初始化的. 而不是按照你在: 后写的顺序:

1
2
3
4
5
6
7
8
9
class CMyClass {
    CMyClass(int x, int y);
    int m_x;
    int m_y;
};

CMyClass::CMyClass(int x, int y) : m_y(y), m_x(m_y)
{
};

这里初始化是先m_x然后m_y,并不是你写的这个顺序. 所以上面这样写是有错误的. 关于这个初始化的错误没有什么好的方法来防止. 你必须确保:后面的顺序和你定义的顺序一致.

析构函数和构造函数

构造函数是在创建一个类的对象是执行的函数, 而析构函数则是删除对象时执行的函数. 二者都是类中的特殊函数.

构造函数

构造函数位于类中, 和类同名并且不会返回任务类型包括void. 构造函数模式情况下是没有参数的, 但是其也可以添加参数. 

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

	public:
		man(string myname);

	private:
		string name;
}

man::man(string myname){
	name = myname;//使用构造函数来初始化
}

一个类中可以有多个构造函数:

1
2
3
4
5
6
7
8
9
class Matrix
{
public:
    Matrix(int row, int col);                                            //普通构造函数
    Matrix(const Matrix& matrix);                                        //拷贝构造函数
    Matrix();                                                            //构造空矩阵的构造函数
    void print(void);
    ~Matrix();//一个析构函数
};

拷贝构造函数

拷贝构造函数是一种特殊的构造函数, 一般用来初始化新的类。在下面三种情况下会调用拷贝构造函数：

  • 一个对象以值传递的方法作为函数的参数传递
  • 一个对象以值传递的方式作为函数的返回值
  • 一个对象需要通过另一个对象进行初始化

实例：

1
2


析构函数

析构函数和构造函数一样, 和类同名, 但是需要使用一个~来标识一个析构函数, 它不会返回任何类型, 也无法有任何参数.

一个类中只可以有一个析构函数

关键字

数据类型

和C语言相比，C++提供了面对对象编程的相关数据类型。

数组和vector

这两者都是一块内存空间。向量的使用方式和数组差不多，但是声明的方式不一样。vector是一个模板类，所有在使用vector时需要添加include <vector>。其声明方式如下：

1
vector<int>name (size)//<>中的是向量中的类型，()中是向量里的数据个数

vector

这个是c++中的一个模板类，但是其是残缺的，必须要使用<type>来指定这个vector的类型，以成为完整的模板类。

由于向量是一个类，所以其还定义了许多成员函数。

面对对象编程

C++ 在 C 语言的基础上增加了面向对象编程，C++ 支持面向对象程序设计。类是 C++ 的核心特性，通常被称为用户定义的类型。

类用于指定对象的形式，是一种用户自定义的数据类型，它是一种封装了数据和函数的组合。类中的数据称为成员变量，函数称为成员函数。类可以被看作是一种模板，可以用来创建具有相同属性和行为的多个对象。

关于类，其实就是一个蓝图，或者是用户自己定义的类型。语法如下：

类的使用

  1. 类中默认的类访问修饰符是private 的，非本类对象无法访问除开public之外二点修饰符。但是具有其他的方法可以访问
  2. 类中的函数是可以直接使用该类中的其他参数的。
  3. this指针, 在一个类中, 由于还不知道这个类的实际对象名称是什么, 所以引用了this指针来指代自己. 在类中函数中, 只要是非静态成员函数, 编译器都会在编译时加上这个this指针作为隐藏参数, 这就是为什么类中的函数可以直接访问类中的数据.

使用实例：

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
#include <string.h>
#include <iostream>

using namespace std;

class man{
    public:
        int age;
        string name;
        string sex;
        string legth;

        void printf_age(void);

        void printf_string(void);

};

void man::printf_string(void)
{
    cout << name << "\n" << sex << "\n" << legth << "\n";
    return ;
}

void man::printf_age(void)
{
    cout << age << "\n";    
    return ;
}
int main (void)
{   
    string name;
    
    man ysc;

    ysc.age = 21;
    ysc.name = "yanshichang";
    ysc.sex = "nan";
    ysc.legth = "176";

    ysc.printf_age();
    ysc.printf_string();

    cout << "places input your name " << endl;

    cin >> name;

    cout << name << endl;

    return 0;
}
C++
#原创
C++信息3笔记-1
https://ysc2.github.io/ysc2.github.io/2024/02/03/C++学习笔记-1/
作者
Ysc
发布于
2024年2月3日
许可协议