13. C++类使用方式


【类】

C语言使用函数将程序代码模块化,C++通过类将代码进一步模块化,类用于将实现一种功能的全局数据、以及操作这些数据的函数集中存储在一起,同时可以设置类成员的访问权限,禁止外部代码使用和篡改本类成员,类成员访问限制的功能由编译器提供,对程序进行逆向分析并修改时并不存在这些限制。

为了区分类成员与类外的全局数据、全局函数,类中的数据称为成员数据、类中的函数称为成员函数。

类的使用方式类似结构体,也是先声明再使用,类的实例称为对象,对象有类型之分,通过哪个声明定义的对象就属于哪个类型。

声明类时需要设置类成员访问权限,限制成员使用范围,类成员有三种访问权限:
1.private,私有成员,只有本类可以使用,外部代码、子类、内部类都不能使用。
2.protected,保护成员,本类和本类的子类可以使用。
3.public,公有成员,可以被任何外部代码使用。

多个类成员可以分别设置为不同的访问权限,编写代码时,类对外提供的功能定义为公有成员,不对外提供的功能定义为私有成员,若类成员未设置访问权限,则默认为私有成员,私有成员不能在类外部直接调用,但是可以被本类的公有成员在外部调用,从而让公有成员执行本类实现的功能。

类可以看做是结构体的扩充版,类可以存储函数,并为内部成员设置访问权限,实际上C++的结构体也可以当做类使用,在结构体内存储函数,结构体与类的唯一区别是成员默认访问权限不同,类成员默认为私有权限,结构体成员默认为公有权限,为了区分类与结构体,一般不会使用结构体代替类,结构体只用于将一些全局数据、成员数据分类存储。

#include <iostream>

/* 使用class声明类 */
class zoo
{
    
/* 公有成员 */
public:
    char name[50];
    int age;
    
    void output()
    {
        printf("姓名:%s\n年龄:%d岁\n\n", name, age);
    }
};    //以;符号结尾

int main()
{
    zoo ali = {"阿狸", 8};    //创建类对象并为成员数据赋值,若类中定义了私有成员数据则不能在创建对象时直接赋值
    ali.output();            //调用成员函数执行
    
    return 0;
}

对象本质

创建多个同类型对象时,这些对象只是成员数据的值不同,成员函数完全相同,这些对象完全没必要各自建立一份自用的成员函数,实际上编译器会对代码进行简化,让多个同类型对象共用一份成员函数。

#include <iostream>
class zoo
{
public:
    char name[50];
    int age;
    void output()
    {
        printf("姓名:%s\n年龄:%d岁\n\n", name, age);
    }
};
int main()
{
    zoo ali = {"阿狸", 8};
    ali.output();
    
    zoo xyy = {"喜羊羊", 9};
    xyy.output();
    
    return 0;
}

上述C++代码等同于如下C语言代码:

#include <stdio.h>
struct zoo
{
    char name[50];
    int age;
};
void output(struct zoo * this)
{
    printf("姓名:%s\n年龄:%d岁\n\n", this->name, this->age);
}
int main()
{
    struct zoo ali = {"阿狸", 8};
    output(&ali);
    
    struct zoo xyy = {"喜羊羊", 9};
    output(&xyy);
    
    return 0;
}

创建对象时,编译器会将对象中的成员数据定义为一个结构体实例,多个对象共用一份成员函数,每个成员函数自动添加一个名为this的指针参数,this指向要操作的结构体实例,既然this指针是实际存在的参数,那当然可以直接使用它,比如下面的代码:

#include <iostream>
class zoo
{
public:
    char name[50];
    int age;
    void output()
    {
        printf("姓名:%s\n年龄:%d岁\n\n", this->name, this->age);    //使用this指针参数调用成员数据
    }
};
int main()
{
    zoo ali = {"阿狸", 8};
    ali.output();
    
    zoo xyy = {"喜羊羊", 9};
    xyy.output();
    
    return 0;
}

成员函数与对象的关系

在语法上,创建对象时包含成员函数,可以通过对象调用成员函数执行。
在功能上,成员函数独立于对象,成员函数通过this指针参数调用操作的对象。

对象使用方式

类对象会被编译为结构体实例,结构体实例的使用方式都可以转移到类对象中。
1.同类型的对象之间可以赋值。
2.对象可以作为函数参数和返回值。
3.类可以嵌套定义。

对象指针

对象指针使用方式类似结构体指针,使用对象指针调用内部成员时,只有成员数据使用指针调用,成员函数会转换为直接调用,原因是所有同类型对象共用一组成员函数,编译器通过“对象指针类型+函数名”即可确定要调用的函数,无需使用间接寻址。

#include <iostream>
class zoo
{
public:
    char name[50];
    int age;
    void output()
    {
        printf("姓名:%s\n年龄:%d岁\n\n", name, age);
    }
};
int main()
{
    zoo ali = {"阿狸", 8};
    zoo *p1 = &ali;
    p1->output();
    
    return 0;
}

上述C++代码相当于如下C语言代码:

#include <stdio.h>
struct zoo
{
    char name[50];
    int age;
};
void put(struct zoo * this)
{
    printf("姓名:%s\n年龄:%d岁\n\n", this->name, this->age);
}
int main()
{
    struct zoo ali = {"阿狸", 8};
    struct zoo *p1 = &ali;
    
    output(p1);    //直接调用函数,而非通过函数指针
    
    return 0;
}

构造函数与析构函数

构造函数和析构函数是编译器自动调用的成员函数,创建对象时自动执行构造函数,对象不再使用后自动执行析构函数。

构造函数

构造函数与类同名,可以在构造函数内定义创建对象后需要首先执行的一些代码,比如为对象赋值、申请内存、打开文件,当然也可以使用普通成员函数完成相关工作,但是普通成员函数需要手动调用,若忘记调用则可能出错。

构造函数使用特点如下:
1.构造函数可以没有,此时创建对象时编译器不会调用构造函数执行。
2.构造函数必须定义为公有权限,否则无法在外部执行。
3.可以有参数,此时需要在创建对象时为构造函数参数赋值,若无参数则完全由编译器自行管理。
4.不能有返回值,因为构造函数由编译器自动调用,无法接收返回值,若需与其他函数通信可以使用成员变量、全局变量实现。
5.可以被重载,编译器根据使用的参数确定调用的重载构造函数。
6.构造函数为对象成员数据赋值时,成员数据默认值不生效(成员数据默认值在之后讲解)。
7.若定义了构造函数,则不能在定义对象时直接为对象赋值,这种限制是为了防止直接赋值与构造函数赋值产生冲突。

#include <iostream>
#include <string.h>
class zoo
{
public:
	char name[50];
	int age;
	void output()
	{
		printf("姓名:%s\n年龄:%d岁\n\n", name, age);
	}
	
	/* 构造函数 */
	zoo()
	{
		name[0] = 0;
		age = 0;
	}
	
	/* 重载构造函数 */
	zoo(const char *s, const int i)
	{
		strncpy(name, s, 49);
		age = i;
	}
};
int main()
{
	zoo x;        //调用无参数构造函数
	x.output();
	
	zoo ali("阿狸", 8);    //调用两个参数的构造函数
	ali.output();
	
	zoo xyy = {"喜羊羊", 9};    //这种语法表示为构造函数参数赋值,而不是直接为对象赋值,{}符号内的数据对应构造函数参数,而非成员数据
	xyy.output();
	
	return 0;
}

析构函数

析构函数会在对象使用完毕后自动执行,可以在析构函数内定义一些函数执行完毕后需要执行的代码,比如释放内存、关闭文件,析构函数也是与类同名,但是需要前缀~符号与构造函数区分。

析构函数执行条件如下:
1.创建此对象的函数执行完毕。
2.对象使用new申请内存存储,之后调用delete释放了内存。

析构函数使用特点如下:
1.析构函数可以没有,此时编译器不会调用析构函数执行。
2.必须定义为公有权限,否则无法在外部执行。
3.没有参数,也没有返回值,若需与其它函数通信可以使用全局变量实现。

#include <iostream>
#include <string.h>
class zoo
{
public:
	char name[50];
	int age;
	
	/* 构造函数 */
	zoo(const char *s, const int i)
	{
		strncpy(name, s, 49);
		age = i;
		
		printf("zoo构造函数执行\n");
	}
	
	/* 析构函数 */
	~zoo()
	{
		printf("zoo析构函数执行\n");
	}
};
int main()
{
	zoo ali("阿狸", 8);
	printf("main函数执行完毕\n");
	
	return 0;
}

编译以上代码并执行,观察构造函数、析构函数的执行顺序。

嵌套类

嵌套定义的类称为内部类,内部类将会当做所属类的成员使用,多数情况下内部类设置为私有权限,不对外开放,只供所属类的其它成员使用。

#include <iostream>
class zoo
{
private:
    class fox
    {
    public:
        char name[50];
        int age;
        void output()
        {
            printf("姓名:%s\n年龄:%d岁\n\n", name, age);
        }
    };
    
public:
    fox ali = {"阿狸", 8};
    fox taozi = {"桃子", 7};
    
    void attr()
    {
        ali.output();
        taozi.output();
    }
};
int main()
{
    zoo zoo1;
    zoo1.attr();
    
    return 0;
}

类中定义本类对象

可以在本类中定义本类的对象,但是只能定义在成员函数内,因为成员函数本质上是独立于类的,若定义为成员数据将会产生无限循环嵌套,导致语法错误。

#include <iostream>
class zoo
{
public:
    char name[50];
    int age;
    void f1()
    {
        zoo ali = {"阿狸", 8};
        printf("姓名:%s\n年龄:%d岁\n\n", ali.name, ali.age);
    }
};
int main()
{
    zoo zoo1;
    zoo1.f1();
    
    return 0;
}

使用new申请对象内存

不带构造函数

#include <iostream>
#include <string.h>
class zoo
{
public:
	char name[50];
	int age;
	void output()
	{
		printf("姓名:%s\n年龄:%d岁\n\n", name, age);
	}
	
	~zoo()
	{
		printf("zoo析构函数执行\n");
	}
};
int main()
{
	zoo * p1 = new zoo;
	strncpy(&p1->name[0], "阿狸", 49);
	p1->age = 8;
	p1->output();
	
	delete p1;          //使用delete释放内存后会自动调用对象析构函数
	
	printf("main函数执行完毕\n");
	
	return 0;
}

带构造函数

#include <iostream>
#include <string.h>
class zoo
{
public:
	char name[50];
	int age;
	void output()
	{
		printf("姓名:%s\n年龄:%d岁\n\n", name, age);
	}
	
	zoo()
	{
		name[0] = 0;
		age = 0;
	}
	zoo(const char *s, const int i)
	{
		strncpy(name, s, 49);
		age = i;
	}
};
int main()
{
	zoo * p1 = new zoo();    //调用无参数构造函数
	p1->output();
	delete p1;
	
	zoo * p2 = new zoo("阿狸", 8);    //调用有参数构造函数
	p2->output();
	delete p2;
	
	return 0;
}

友元

类成员如果不考虑继承关系,只有公有、私有两种访问权限,要么禁止所有外部代码访问,要么允许所有外部代码访问,这种权限设置不灵活,所以C++增加了友元功能,友元是为某个外部代码单独设置的访问权限,可以让指定的类、成员函数、全局函数访问本类的私有成员。

友元最常用于内部类,将本类的内部类定义为友元,之后内部类就可以使用所属类的私有成员。

友元使用特点如下:
1.友元关系不会被继承。
2.友元关系是单向的,若需使用双向友元则需要在两个类中同时设置对方为自己的友元。
3.在友元中创建本类对象时不能直接赋值,可以使用构造函数赋值。

友元类

#include <iostream>
#include <string.h>
class zoo
{
	/* 使用friend关键词设置k类为友元 */
	friend class k;
	
private:
	char name[50];
	int age;
	void output()
	{
		printf("姓名:%s\n年龄:%d岁\n", name, age);
	}
	
	zoo(const char *s, const int i)
	{
		strncpy(name, s, 49);
		age = i;
	}
};
class k
{
public:
	void f1()
	{
		zoo ali("阿狸", 8);
		ali.output();
	}
};
int main()
{
	k k1;
	k1.f1();
	
	return 0;
}

友元成员函数

可以单独设置某个类的成员函数为友元,但是此函数必须在类外定义内容,并且有固定的定义顺序,顺序如下:
1.定义友元成员函数所属类。
2.定义需要设置友元关系的类。
3.在类外部定义友元成员函数的内容代码。

#include <iostream>
#include <string.h>

/* 定义友元成员函数所属类 */
class k
{
public:
	void f1();    //只定义友元成员函数主体部分,不定义内容
};

/* 定义设置友元的类 */
class zoo
{
	friend void k::f1();    //设置友元成员函数,若函数有参数则需要同时指定参数类型和名称
	
private:
	char name[50];
	int age;
	void output()
	{
		printf("姓名:%s\n年龄:%d岁\n", name, age);
	}
	
	zoo(const char *s, const int i)
	{
		strncpy(name, s, 49);
		age = i;
	}
};

/* 定义友元成员函数内容 */
void k::f1()
{
	zoo ali("阿狸", 8);
	ali.output();
}

int main()
{
	k k1;
	k1.f1();
	
	return 0;
}

友元全局函数

#include <iostream>
#include <string.h>
class zoo
{
	friend int main();    //设置main为友元
	
private:
	char name[50];
	int age;
	void output()
	{
		printf("姓名:%s\n年龄:%d岁\n", name, age);
	}
	
	zoo(const char *s, const int i)
	{
		strncpy(name, s, 49);
		age = i;
	}
};
int main()
{
	zoo ali("阿狸", 8);
	ali.output();
	
	return 0;
}


【成员数据使用细节】

成员数据默认值

声明成员数据时可以设置默认值,公有成员、私有成员都可以设置默认值,创建对象时若不赋值则编译器使用默认值自动赋值,若构造函数也会为对象赋值,则以构造函数为准。

#include <iostream>
class math
{
public:
    int a=0, b=0;    //设置默认值
    void add()
    {
        printf("a+b=%d\n", a+b);
    }
};
int main()
{
    math math1;           //使用默认值
    math1.add();          //输出0
    
    math math2 = {1,2};   //自行赋值
    math2.add();          //输出3
    
    return 0;
}

常量成员数据

若成员数据定义为常量,则需要在创建对象时直接赋值,之后不能修改,只能读取它的值,若不为常量成员数据赋值则必须设置默认值。

注意不能使用构造函数为常量成员数据赋值,因为对象的创建早于构造函数的执行,此时等于使用构造函数修改常量成员数据,将会禁止编译。

私有成员数据

类成员应该尽量定义为私有的,不需要被外部代码调用的成员都应该设置为私有权限,防止被类外代码调用、修改导致出错,因为类成员不能在类外直接调用,所以类中包含私有成员数据时创建本类对象不能直接赋值,私有成员数据可以使用如下方式赋值:

1.设置默认值。
2.使用构造函数赋值。
3.使用其他公有函数赋值。

#include <iostream>
class math
{
private:
	int a,b;
	
public:
	void add()
	{
		printf("a+b=%d\n", a+b);
	}
	void mul()
	{
		printf("a*b=%d\n", a*b);
	}
	
	math(int i1, int i2)
	{
		a = i1;
		b = i2;
	}
};
int main()
{
	math math1(1,2);
	math1.add();
	math1.mul();
	
	return 0;
}


【成员函数使用细节】

成员函数在类外部定义内容

成员函数内容代码可以放在所属类外部定义,类中只定义成员函数的主体,这样方便阅读类实现的整体功能。

#include <iostream>
class math
{
private:
	int a,b;
	
public:
	void add();    //类中定义函数主体部分,若有参数则需要同时定义参数
	void mul();
	
	math(int i1, int i2)
	{
		a = i1;
		b = i2;
	}
};

/* 类外定义成员函数内容,因为不同类的成员可以同名,所以这里需要指定函数所属的类 */
void math::add()
{
	printf("a+b=%d\n", a+b);
}
void math::mul()
{
	printf("a*b=%d\n", a*b);
}

int main()
{
	math math1(1,2);
	math1.add();
	math1.mul();
	
	return 0; 
}

常量成员函数

常量成员函数是只读取成员数据、不修改成员数据的成员函数,而且它只能调用其他常量成员函数执行,不能调用非常量成员函数,这是为了防止通过调用非常量成员函数间接修改成员数据。

常量成员函数主要作用是服务于常量对象,对象可以定义为常量,防止被修改,常量对象中的成员函数只有常量成员函数可以执行,原因同上,类中不修改成员数据的函数都应该定义为常量成员函数,这样不仅可以被常量对象调用、还可以防止编写代码时不小心错误的修改了成员数据。

注:常量对象可以使用构造函数赋值,这与在类中定义常量成员数据不同,编译器会首先执行构造函数然后限制常量对象被修改。

#include <iostream>
class math
{
public:
	int a,b;
	
	/* 定义常量成员函数,const关键词写在参数之后 */
	void add() const
	{
		printf("a+b=%d\n", a+b);
	}
	
	void mul() const
	{
		printf("a*b=%d\n", a*b);
	}
};
int main()
{
	const math math1 = {1,2};    //定义常量对象,只能调用常量成员函数执行
	math1.add();
	math1.mul();
	
	return 0; 
}

成员函数指针

本类内部使用成员函数指针

#include <iostream>
class math
{
private:
	int a,b;
	
public:
	math(int i1, int i2)
	{
		a = i1;
		b = i2;
	}
	
	int add() const
	{
		return a+b;
	}
	int mul() const
	{
		return a*b;
	}
	void output() const
	{
		int result;
		
		int(math::*p1)()const = &math::add;    //p1为指针名,const表示指向常量成员函数,赋值为add函数地址
		result = (this->*p1)();                //使用指针执行成员函数
		printf("a+b=%d\n", result);
		
		p1 = &math::mul;
		result = (this->*p1)();
		printf("a*b=%d\n", result);
	}
};
int main()
{
	math math1(1,2);
	math1.output();
	
	return 0;
}

使用成员函数指针注意事项如下:
1.定义成员函数指针时,需要指定指针所属类,此指针只能指向本类中的成员函数,包括继承自父类的函数。
2.成员函数指针赋值时,需要指定成员函数所属类,即使成员函数与成员函数指针就在同一个类中。
3.执行指针指向的函数时,需要使用this参数调用成员函数指针、然后通过成员函数指针调用指向的函数,编译器会使用本函数this参数为执行函数的this参数赋值。

本类外部使用成员函数指针

使用对象指针调用成员函数时会转换为直接寻址,成员函数并非通过指针调用,若有此需求可以在本类外部使用成员函数指针,成员函数在所属类之外通过指针调用时需要首先其所属类对象,并使用此对象的地址为成员函数的this参数赋值。

#include <iostream>
class math
{
private:
	int a, b;
	
public:
	math(int i1, int i2)
	{
		a = i1;
		b = i2;
	}
	
	void add() const
	{
		printf("a+b=%d\n", a+b);
	}
	void mul() const
	{
		printf("a*b=%d\n", a*b);
	}
};
int main()
{
	math math1(1,2);           //定义math对象
	
	void(math::*p1)()const;    //定义math类的成员函数指针
	
	p1 = &math::add;
	(math1.*p1)();      //通过指针执行函数,需要指定对象名,成员函数使用此对象为this参数赋值
	
	p1 = &math::mul;
	(math1.*p1)();
	
	return 0;
}


【静态类成员】

类成员可以定义为静态的,静态成员直接通过类名调用,创建对象时不会包含类静态成员,就像C语言中静态局部变量等于全局变量、不包含在函数中一样。

静态类成员的作用是将一些全局数据、全局函数放在类中管理,方便将全局代码进行分类。

静态成员数据特点如下:
1.不能设置默认值,因为此数据本质上不属于此类成员。
2.需要在类外定义一遍,否则禁止编译,可以同时设置初始值,类内只是声明此数据的所属权,而非定义此数据。

静态成员函数特点如下:
1.不能操作所属类的非静态成员,因为静态成员函数没有this指针参数。
2.可以调用所属类的其它静态成员。

#include <iostream>
class math
{
public:
    /* 静态成员数据 */
    static int a, b;
    
    /* 静态成员函数 */
    static void add()
    {
        printf("a+b=%d\n", a+b);
    }
};
int math::a = 0;    //静态成员数据在类外定义
int math::b = 0;
int main()
{
    math::a = 1;    //使用类名调用静态类成员,也可以使用对象名调用,调用的都是同一个数据
    math::b = 2;
    math::add();
    
    return 0;
}

上述C++代码等同于如下C语言代码:

#include <stdio.h>
int a=0, b=0;
void add()    //add函数没有this指针参数
{
    printf("a+b=%d\n", a+b);
}
int main()
{
    a = 1;
    b = 2;
    add();
    
    return 0;
}

静态类成员指针

静态类成员指针的定义方式与全局数据相同,只不过在赋值时需要额外指定数据所在类。

#include <iostream>
class math
{
public:
	static int a, b;
	static void add()
	{
		printf("a+b=%d\n", a+b);
	}
};
int math::a = 0;
int math::b = 0;
int main()
{
	int * p1 = &math::a;
	*p1 = 1;
	
	int * p2 = &math::b;
	*p2 = 2;
	
	void(*p3)() = &math::add;
	p3();
	
	return 0;
}


 

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/434456.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

SMT贴片加工——品质检验要求

一、元器件贴装工艺品质要求 1.元器件贴装需整齐、正中&#xff0c;无偏移、歪斜 2.贴装的元器件型号规格应正确&#xff1b;元器件应无漏贴、错贴 3.贴片元器件不允许有反贴 4.有极性要求的贴片器件安装需按正确的极性标示安装 二、元器件焊锡工艺要求 1.FPC板面应无影响…

Java实现读取转码写入ES构建检索PDF等文档全栈流程

背景 之前已简单使用ES及Kibana和在线转Base64工具实现了检索文档的demo&#xff0c;并已实现WebHook的搭建和触发流程接口。 传送门&#xff1a; 基于GitBucket的Hook构建ES检索PDF等文档全栈方案 使用ES检索PDF、word等文档快速开始 实现读取本地文件入库ES 总体思路&…

真空展|2024上海国际真空技术及设备展览会

2024上海国际真空技术及设备展览会 2024 Shanghai International Exhibition of vacuum technology and equipment 时 间&#xff1a;2024年7月13-15日 地 点&#xff1a;上海新国际博览中心 承办单位&#xff1a;上海昶文展览服务有限公司 展会简…

JVM内部世界(内存划分,类加载,垃圾回收)

&#x1f495;"Echo"&#x1f495; 作者&#xff1a;Mylvzi 文章主要内容&#xff1a;JVM内部世界(内存划分,类加载,垃圾回收) 关于JVM的学习主要掌握三方面: JVM内存区的划分类加载垃圾回收 一.JVM内存区的划分 当一个Java进程开始执行时,JVM会首先向操作系统申…

CSS常见布局方式

一、静态布局&#xff08;Static Layout&#xff09; 既传统web设计 就是不管浏览器尺寸多少&#xff0c;网页布局就按当时写代码的布局来布置; 块级元素&#xff1a;每个块级元素会在上一个元素下面另起一行&#xff0c;他们会被设置好的margin分离。块级元素是垂直组织的。 …

SQL Server 安装部署

SQL Server是运行在win server上的关系型数据库&#xff0c;本文主要描述SQL Server的安装部署。 如上所示&#xff0c;SQL Server不同版本的定义以及特性 如上所示&#xff0c;SQL Server不同版本支持的容量规模 如上所示&#xff0c;SQL Server不同版本支持的高可用性 如上所…

能源大数据采集,为您提供专业数据采集服务

随着经济的不断发展&#xff0c;能源产业也逐渐成为国民经济的支柱产业之一。而对于能源行业来说&#xff0c;数据采集是一项至关重要的工作。以往&#xff0c;能源企业采集数据主要依靠人工收集、整理&#xff0c;但是这种方式不仅效率低下&#xff0c;而且容易出现数据不准确…

springcloud:3.7测试线程池服务隔离

服务提供者【test-provider8001】 Openfeign远程调用服务提供者搭建 文章地址http://t.csdnimg.cn/06iz8 相关接口 测试远程调用&#xff1a;http://localhost:8001/payment/index 服务消费者【test-consumer-resilience4j8004】 Openfeign远程调用消费者搭建 文章地址http://t…

ARM中专用指令(异常向量表、异常源、异常返回等)

状态寄存器传送指令 CPSR寄存器 状态寄存器传送指令:访问&#xff08;读写&#xff09;CPSR寄存器 读CPSR MRS R1, CPSR R1 CPSR 写CPSR MSR CPSR, #0x10 0x10为User模式&#xff0c;且开启IRQ和FRQ CPSR 0x10 在USER模式下不能随意修改CPSR&#xff0c;因为USER模式…

7.使用os.Args或flag解析命令行参数

文章目录 一、os.Args二、flag包基本使用 Go语言内置的flag包实现了命令行参数的解析&#xff0c;flag包使得开发命令行工具更为简单。 一、os.Args 如果你只是简单的想要获取命令行参数&#xff0c;可以像下面的代码示例一样使用os.Args来获取命令行参数。 package mainimp…

数据伪列

目录 数据伪列 rownum 查询 emp 表中的记录并且取得第一行数据 取得 emp 表的前 5 行记录 rowid 面试题&#xff1a;表中有许多完全重复的数据&#xff0c;要求将重复的数据删除掉&#xff08;只剩最早的一个&#xff09; Oracle从入门到总裁:https://blog.csdn.net/weixin…

图像检索与识别——词袋模型(Bag-of-features models)

一、定义 计算机视觉单词袋是一种描述计算图像之间相似度的技术&#xff0c;常用于用于图像分类当中。该方法起源于文本检索&#xff08;信息检索&#xff09;&#xff0c;是对NLP“单词袋”算法的扩展。在“单词袋”中&#xff0c;我们扫描整个文档&#xff0c;并保留文档中出…

Axure 入门文档 文件格式 全局样式 元件居中

文件格式 .rp 原型文件.rplib:元件库文件.rpteam 团队项目文件.html 项目网页文件 批量设置居中 选中多个&#xff0c;然后上方任务栏即可设置 设置自定义页面视图尺寸 项目-自适应视图设置 点击页面空白处就可以使用 添加元件说明 当一个元件创建好&#xff0c;可以设…

java spring 02. AbstractApplicationContext的refresh

spring创建对象的顺序&#xff0c;先创建beanfactory&#xff0c;再会把xml文件读取到spring。 public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, Nullable ApplicationContext parent)throws BeansException {//调用父类的构造方法super(p…

MQTT连接阿里云物联网上报物模型数据

目录 1. 创建产品&#xff08;物联网平台 -> 产品 -> 创建产品&#xff09; 2. 为产品添加设备 3. 添加物模型 4. mqtt.fx连接测试 5. 调试物模型 6. 使用mqtt.fx上报温度数据 1. 创建产品&#xff08;物联网平台 -> 产品 -> 创建产品&#xff09; 我这里再新…

⭐每天一道leetcode:35.搜索插入位置(简单;二分速查)

⭐今日份题目 给定一个排序数组和一个目标值&#xff0c;在数组中找到目标值&#xff0c;并返回其索引。如果目标值不存在于数组中&#xff0c;返回它将会被按顺序插入的位置。 请必须使用时间复杂度为 O(log n) 的算法。 示例1 输入: nums [1,3,5,6], target 5 输出: 2 …

网络学习:Vlan间路由

目录 一、vlan间路由实现的方法 二、精确匹配转发&#xff08;交换机&#xff09;流程 三、最长匹配转发&#xff08;路由器&#xff09; 四、交换机最长匹配转发 五、总结 一、vlan间路由实现的方法 方法1&#xff1a;使用路由器的物理接口 特点&#xff1a;在路由器上…

ETAS工具链ISOLAR-AB重要概念,RTE配置,ECU抽取

RTE配置界面&#xff0c;包含ECU抽取关联 首次配置RTE&#xff0c;出现需要勾选的抽取EXTRACT 创建System System制作SWC到ECU的Mapping System制作System Data 的Mapping

Redis--线程模型详解

Redis线程模型 Redis内部使用的文件事件处理器&#xff08;基于Reactor模式开发的&#xff09;file event handler是单线程的&#xff0c;所以Redis线程模型才叫单线程模型&#xff0c;它采用IO多路复用机制同时监听多个socket&#xff0c;当被监听的socket准备好执行accep、r…

就业班 2401--3.6 Linux Day12--计划任务和邮件和ssh远程连接

一、计划任务 计划任务概念解析 在Linux操作系统中&#xff0c;除了用户即时执行的命令操作以外&#xff0c;还可以配置在指定的时间、指定的日期执行预先计划好的系统管理任务&#xff08;如定期备份、定期采集监测数据&#xff09;。RHEL6系统中默认已安装了at、crontab软件…