技术标签: c++
程序一般由类的定义和类的使用两部分组成
程序中的操作都是通过想对象发送消息来实现的,对象接收到消息后,启动有关方法完成操作
一组具有相同属性和行为的对象的抽象
类和对象之间的关系:抽象和具体的关系
一个对象是类的一个实例
在面向对象程序设计中,先声明类,再由类生成其对象
对象的交互:对象之间的联系
消息传递机制:允许一个对象与另一个对象的交互
消息的性质:
抽象:通过特定的实例抽取共同性质后形成概念的过程
封装:把数据和实现操作的代码集中起来放在对象内部,并尽可能隐蔽对象的内部细节
C++对象中的函数名就是对象的对外接口
好处:降低了人们操作对象的复杂程度,隐藏了复杂性,提供了代码重用性,减轻了开发软件系统的难度
各个对象相互独立、互不干扰
信息隐蔽:对外界隐蔽的做法,有利于数据安全,防止无关人员访问和修改数据
继承:某个类可以继承另一个类的特征和能力
若类之间具有继承关系,则它们具有以下特征:
1.类间具有共享特征
2.类间具有差别或新增部分
3.类间具有层次结构
作用:避免公用代码的重复开发,减少代码和数据冗余,增强一致性来减少模块间的接口和界面
多态:不同的对象收到相同的消息时执行不同的操作
增强了软件的灵活性和重用性,为软件开发与维护提供了极大的便利
可提高程序的重用性
可控制程序的复杂性
可改善程序的可维护性
能更好地支持大型程序设计
增强了计算机处理信息的范围
能很好地适应新的硬件环境
注释:1. //开始,到行尾结束 2. /**/,可以嵌套//
C++源程序文件扩展名.cpp
using namespace std 使用命名空间std,可以保证对C++标准库操作的每一个特性都是唯一的,不至于发生命名冲突
使用、等都需要加using namespace std ,若采用带.h的头文件时,则不需要加
两种头文件不可混用
见7.6
标准输入流对象cin(c+in)标准输出流对象cout(c+out)更安全更方便
cin:在程序中用于代表标准输入设备,通常指键盘
>>在c++中仍保持右移功能,用于输入时表示将从标准输入流对象cin读取的数值传送给右方指定的变量
当输入字符串(即类型为string的变量)时,提取运算符“>>”的作用是跳过空白字符,读入后面的非空白字符,直到遇到另一个空白字符为止,并在串尾放一个字符串结束标志‘\0’。
cin>>x 必须加>>,x必须是基本数据类型不能是,void类型
允许输入一连串数据cin>>a>>b>>c,两个数据间用空白符(空格、回车、Tab键)分隔
cout:在程序中用于代表标准输出设备,通常指屏幕
<<在c++中仍保持左移功能,用于输入时表示将右方变量的值写到标准输出流对象cout中
cin<<y 必须加<<,y必须是基本数据类型不能是,void类型
允许输入一连串数据cout<<a+b<<c
I/O格式:设置转换基数的操作符:dec(十进制)、hex(十六进制)、oct(八进制)
换行操作符endl,作用与\n一样
cout<<hex<<x<<’ '<<dec<<x<< ’ '<<endl
允许变量声明与可执行语句在程序中交替出现
允许在代码块中的任何地方说明局部变量,从说明点到该变量所在的最小分程序末的范围有效,且符合先定义后使用
在定义变量时,不必在结构名、联合名、枚举名前加struct、union、enum
enum Bool {FALSE,TRUE};
struct String
{ char * ptr;
int length;
};
Bool done; //定义时不加struct、union、enum
String str; //c语言中必须加struct、union、enum
#define:#define PI 3.14 将程序中的PI替换为3.14,编译后程序中不再出现PI这个标识符,PI不是变量,无类型,不占存储单元,易出错
const:const int i=10 这个常量i是有类型的,占用存储单元,有地址,可以用指针指向它,但是不可修改,消除了#define的不安全性
const和指针:
const char * name="chen";
name[3]='a'; //出错,不允许改变指针所指的常量
name="zhang" //合法,可以改变指针所指的地址```
char * const name="chen";
name[3]='a'; //合法,允许改变指针所指的常量
name="zhang" //出错,不允许改变指针所指的地址
const char * const name="chen";
name[3]='a'; //出错,不允许改变指针所指的常量
name="zhang" //出错,不允许改变指针所指的地址
说明:
在C++中,如果函数调用的位置在函数定义之前,则要求在函数调用之前必须对所调用的函数作函数原型声明,以说明函数的名称、参数类型与个数,以及函数返回值的类型,其主要目的是让c++编译程序进行检查,以确定调用函数的参数以及返回值类型与事先定义的原型是否相符,以保证程序的正确选。
f();与f(void);完全一样,表示该函数不带任何参数
f(void);表示该函数不带任何参数,f();的参数信息没有给出,可能有参数
void通常表示无值,但将void作为指针的类型时,它却表示不确定的类型。这种void型指针是一种通用型指针,也就是说任何类型的指针值都可以赋给void类型的指针变量。
需要指出的是,这里说void型指针是通用指针,是指它可以接受任何类型的指针的赋值,但对已获值的void型指针,对它进行再处理,如输出或者传递指针值时,则必须再进行显式类型转换,否则会出错。
void* pc;
int i = 123;
char c = 'a';
pc = &i;
cout << pc << endl; //输出指针地址006FF730
cout << *(int*)pc << endl; //输出值123
pc = &c;
cout << *(char*)pc << endl; //输出值a
在函数说明前冠以关键字“inline”,该函数就被声明为内联函数,又称内置函数。每当程序中出现对该函数的调用时,C++编译器使用函数体中的代码插入到调用该函数的语句处,同时用实参代替虚参,以便在程序运行时不再进行函数调用。
引入内联函数主要是为了消除调用函数时的系统开销,以提高运行速度。
说明:
C++允许实参个数与形参个数不同
当进行函数调用时,编译器按从左到右的顺序将实参与形参结合,若未指定足够的实参,则编译器按顺序用函数原型中的默认值来补足所缺少的实参。
int fun(int a, int b, int c = 111);
在同一作用域内,只要函数参数的类型不同,或者参数的个数不同,或者二者兼而有之,两个或者两个以上的函数可以使用相同的函数名。
说明:
void Drawcircle(int r = 0, int x = 0, int y = 0);
void Drawcircle(int r);
Drawcircle(20);
void f_a(int x);
void f_a(long x);
int c=f_a(20.83); //无法确定转换为int还是long
通常情况下,如果有两个同名变量,一个是全局的,另一个是局部的,那么局部变量在其作用域内具有较高的优先权,它将屏蔽全局变量。
如果希望在局部变量的作用域内使用同名的全局变量,可以在该变量前加上“::”,此时::value代表全局变量value,“::”称为作用域标识符。
C++中的一种特殊联合,在关键字union后没有给出联结名,可使得一组数据成员共享同一内存地址
union
{ int i;
double d;
}x;
在访问无名变量时,不能访问无名联合变量,而是应该访问联合变量中的成员,如 x.d x.i
C语言
int i=10;
double x=(double)i;
C++
int i=10;
double x=double(i);
程序运行时,计算机的内存被分为4个区:程序代码区、全局数据区、堆和栈。其中,堆可由用户分配和释放。C语言中使用函数malloc()和free()来进行动态内存管理。C++则提供了运算符new和delete来做同样的工作,而且后者比前者性能更优越,使用更灵活方便。
说明:
指针变量名=new 类型;
int * p;
p=new int;
指针变量名 = new 类型名[下标表达式];
int * p = new int[10];
delete []指针变量名;
指针变量名 = new 类型名(初值);
int *p;
p = new int(99)
delete 指针变量名; //指针变量保存着new分配的内存的首地址
delete p;
使用malloc函数时必须使用sizeof函数来计算所需要的字节数,new可以根据数据类型自动计算所要分配内存的大小,减少错误发生
new能够自动返回正确的指针类型,mall哦草必须在程序中进行强制数据类型转换
建立引用的作用:为变量另起一个名字,变量的引用被认为变量的别名
#include <iostream>
using namespace std;
void swap(int &a, int &b)
{
int t = a;
a = b;
b = t;
}
int a[] = {1, 3, 5, 7, 9};
int & index(int i)
{
return a[i];
}
int main()
{
int a = 5, b = 10;
//交换数字a和b
swap(a, b);
cout << "a = " << a << " b = " << b << endl;
cout << index(2) << endl; //等价于输出元素a[2]的值
index(2) = 100; //等价于将a[2]的值赋为100;
cout << index(2) << endl;
return 0;
}
比结构体类型更安全有效的数据类型——类
class 类名{
public:
公有数据成员;
公有成员函数;
protected:
保护数据成员;
保护成员函数;
private:
私有数据成员;
私有成员函数;
}; //最后一定要加分号 //从 { 到 } 是类体
成员访问限定符:(声明各成员的访问属性)
可以访问本类中的任何组成员
返回值类型 类名::成员函数名(参数表)
{
函数体
}
一个类也就是用户声明的一个数据类型
声明一个类,并不接受和存储具体的值
对象的定义:
}op1, op2;
对象中成员的访问:
对象名.数据成员名 对象名.成员函数名[ (实参表) ]
class date{
public:
int year;
};
date d,*p;
p=&d;
cout<<p->year; // d.year (* p).year p->year 三者等价
类的作用域:在类的声明中的一对花括号所形成的作用域。在类的作用域内,任何成员函数可以不受限制地访问该类中的其他成员
一般,公有成员是类的对外接口,私有成员是类的内部数据和内部实现不希望外界访问
将类的成员划分为不同的访问级别好处:信息隐蔽,数据保护
类声明中不能给数据成员赋初值
class Complex{
double real=0;/**/错误的**
};
如果一个类中的所有成员都是公有的,可以在定义对象时对数据成员进行初始化
class Complex{
public:
double real;
double imag;
};
Complex c1={1.1,2.2};
如果类中包含私有成员或保护成员,可以采用类中的公有成员函数来对对象中的数据成员赋初值
Complex(){ //不带参数的构造函数
real=0;
imag=0;
}
在建立对象时采用构造函数给数据成员赋初值,有两种形式:
类名 对象名 [ (实参表) ];
类名 * 指针变量名=new 类名 [ (实参表) ]; //这个对象没有名字,称为 无名对象 // delete 指针变量名
在函数首部实现
类名 ::构造函数名 ( [参数表] ) :数据成员名1(初始值1),数据成员名2(初始值2), ......
{ //构造函数体
}
对于用const修饰的数据成员,或是引用类型的数据成员,不允许用赋值语句直接赋值,可以用成员初始化列表
#include <iostream>
using namespace std;
class Date
{ public:
Date (); //声明1个无参数的构造函数
Date (int y,int m,int d); //声明1个带有3个参数的构造函数
void showDate();
private:
int year;
int month;
int day; //一个类中可以包含多个构造函数,但对每个对象而言,建立对象时只执行其中一个构造函数
};
Date::Date () //只要类中定义了一个构造函数,系统将不再提供默认构造函数
{ year=2000; month=4; day=28;
}
Date::Date (int y,int m,int d)
{ year=y; month=m day=d;
}
inline void showDate()
{ cout<<year<<"."<<month<<"."<<day<<endl;
}
int main()
{ Date date1; //使用无参构造函数创建对象时,用这个Date date1; 不能用Date date1();表示声明一个函数名为date1返回值类型为Date的普通函数
date1.showDate();
Date date2(2002,11,14);
date2.showDate();
return 0;
}
Complex (double r=0.0,double i=0.0); //在声明构造函数时指定默认参数
Complex::Complex(double r,double i) //在类外定义构造函数时,可以不再指定参数的默认值
{real=r; imag=i}
每一个数组元素都是对象的数组
有几个数组元素就调用几次构造函数
类名 数组名[下标表达式]
exam ob1 [4] = {89, 97, 79, 88}; //用只有1个参数的构造函数给对象数组赋值
Exam ob2 [4] = {89, 90}; //用不带参数和带1个参数的构造函数给对象数组赋值,
//先调用带1个参数的构造函数初始化ob2[0]和ob2[1],再调用不带参数的构造函数初始化ob2[2]和ob2[3],
Complex com [3]={
Complex (1,2),
Complex (3,4),
Complex (5,6)
}; //用带有多个参数的构造函数给对象数组赋值
每一个对象在初始化后都会在内存中占有一定的空间。因此,既可以通过对象名访问对象,也可以通过对象地址来访问对象。对象指针就是用于存放对象地址的变量。声明对象指针的语法形式为:
类名 * 对象指针名;
用指针访问单个对象成员 exe ob,*p; p=&ob; p->show(); (*p).show();
用对象指针访问对象数组 exe ob[2],*p; p=ob;
实际上,给对象赋值就是给对象的数据成员赋值
C++的编译系统只用了一段空间来存放共同的函数代码,
每一个对象的存储空间都只是数据成员所占用的存储空间,函数代码是存储在对象空间之外
称为自引用指针
每当创建一个对象时,系统把this指针初始化为指向该对象,this指针的值是当前调用成员函数的对象的起始地址
this指针是隐式使用的,是作为参数被传递给成员函数的
void disp() {cout<<"x="<<x<<endl;}
实际使用时,c++编译系统把它处理为:
void disp(*this) {cout<<"x="<<this->x<<endl;}
C++支持两种类型的字符串,第一种是C语言中介绍过的、包括一个结束符’\0’(即以NULL结束)的字符数组,标准库函数提供了一组对其进行操作的函数,可以完成许多常用的字符串操作。如:strcpy、ctrcat、strlen等
C++仍保留了这种格式字符串;
C++标准库中声明了一种更方便的字符串类型,即字符串类string,类string提供了对字符串进行处理所需要的操作。使用string类必须在程序的开始包括头文件string,即要有以下语句:#include <string>
string 对象1,对象2,......;
strnig str1, str2("china"), str3="administrator"
在表达式中,可以string类对象和以‘\0’结束的字符串混在一起使用
void show(类名 对象名)
B=A; 将对象A的数据成员逐位复制给B
Point p2(p1);
自定义:
类名::类名(const 类名 &对象名)
{
//函数体 通过自定义可以 有选择有变化地复制,如乘2后赋值
}
调用:
类名 对象2(对象1);//代入法
类名 对象2=对象1; //赋值法
当类中有指针类型时,调用默认拷贝构造函数有时会产生错误
调用拷贝构造函数的三种情况:
为了实现一个类的多个对象之间的数据共享
可以全局变量
将一个数据成员说明为static,静态数据成员。无论建立多少个类的对象,都只有一个静态数据成员的拷贝
static 数据类型 数据成员名;
数据类型 类名::静态数据成员名=初始值;
类名::静态数据成员名
对象名.静态数据成员名; 对象指针->静态数据成员名;
在类定义中,前面有static说明的成员函数称为静态成员函数。静态成员函数属于整个类,是该类所有对象共享的成员函数,而不属于类中的某个对象。静态成员函数的作用不是为了对象之间的沟通,而是为了处理静态数据成员。定义静态成员函数的格式如下:
static 返回类型 静态成员函数名(参数表);
类名::静态成员函数名(实参表);
对象.静态成员函数名(实参表);
对象指针->静态成员函数名(实参表);
类名::静态成员函数名()
类的主要特点之一是数据隐藏和封装,即类的私有成员(或保护成员)只能在类定义的范围内使用,也就是说私有成员只能通过它的成员函数来访问。但是,有时为了访问类的私有成员而需要在程序中多次调用成员函数,这样会因为频繁调用带来较大的时间和空间开销,从而降低程序的运行效率。为此,C++提供了友元来对私有或保护成员进行访问。友元包括友元函数和友元类。
友元函数既可以是不属于任何类的非成员函数,也可以是另一个类的成员函数。友元函数不是当前类的成员函数,但它可以访问该类的所有成员,包括私有成员、保护成员和公有成员。
class Girl{
public;
......
friend void disp(Girl &);
}
void disp(Girl &x)
{ cout<<x.name<<endl; }
class Girl{
public;
......
friend void prdata(const Girl &,const Boy &);
}
class Boy{
public;
......
friend void prdata(const Girl &,const Boy &);
}
void prdata(const Girl &g,const Boy &b)
{ cout<<g.name<<endl;
cout<<b.name<<endl; }
class Girl; //为Girl类的提前引用声明
class Boy{
public;
......
void prdata(Girl &);
}
class Girl{
public;
......
friend void Boy::prdata(Girl &); //声明类Boy的成员函数prdata为类Girl的友元函数
}
void prdata(Girl &x)
{ cout<< name<<endl;
cout<<x.name<<endl; }
int main ()
{ Boy b("李华",11);
Girl g("小红",22);
b.prdata(g);
return 0; } //结果是两个对象的内容
friend 类名; //此类名为友元类的,这条语句可以放在公有部分,也可在私有部分
class Y{......};
class X{
....
friend Y;
};
当一个类被说明为另一个类的友元类时,它所有的成员函数都成为另一个类的友元函数,这就意味着作为友元类中的所有成员函数都可以访问另一个类中的所有成员。
友元关系单向的,不具有交换性和传递性。
在一个类中内嵌另一个类的对象作为数据成员,称为类的组合。该内嵌对象称为对象成员,又称为子对象。
class A{
···
};
class B{
A a;
public:
···
};
class X{
类名1 对象成员1;
类名2 对象成员2;
...
};
类X的构造函数的定义形式:
X::X(形参表0) : 对象成员1(形参表1),对象成员2(形参表2),.......
{ 函数体 } //对象成员1(形参表1),对象成员2(形参表2),.......是 初始化表,作用是对对象成员进行初始化
当调用构造函数X::X()时,首先按各内嵌对象成员在类声明中的顺序依次调用它们的构造函数进行初始化,最后再执行类X的构造函数体,初始化其他成员。析构函数的调用顺序与构造函数相反
常类型的引入就是为了既保护数据共享又防止数据被改动。
常类型是指使用类型修饰符const说明的类型,
常类型的变量或对象成员的值在程序运行期间是不可改变的。
如果在说明引用时用const修饰,则被说明的引用为常引用。常引用所引用的对象不能被更新。如果用常引用做形参,便不会产生对实参的不希望的更改。
const 类型 & 引用名;
经常用作函数的形参,常参数`
如果在说明对象时用const修饰,则被说明的对象为常对象。常对象的数据成员在对象的整个生存期内不能改变,为常量且必须要有初值。
类名 const 对象名[ 参数表 ];
或者
const 类名 对象名[ 参数表 ];
在定义对象是必须进行初始化
类型说明符 函数名(参数表) const;
继承可以在已有类的基础上创建新的类,新类可以从一个或多个已有类中继承成员函数和数据成员,而且可以重新定义或加进新的数据和函数,从而形成类的层次或等级。其中,已有类称为基类或父类,在它基础上建立的新类称为派生类或子类。
从已有类产生新类的过程,类的派生
class 派生类名: 继承方式 基类名{
派生类新增的数据成员和成员函数
}; //继承方式:public或private或protected 默认为私有继承
派生类中的成员包括从基类继承过来的成员和自己增加的成员
1)派生类从基类接受成员
2)调整从基类接受来的成员
一方面是改变基类成员在派生类中的访问属性
另一方面是派生类可以对基类的成员进行重定义:
在派生类中声明一个与基类成员同名的成员,则派生类中的新成员会覆盖基类中的同名成员
3)在派生类中增加新成员
基类中的构造函数和析构函数是不能被继承的
基类中的成员 | 在公有派生类中的访问属性 | 在私有派生类中的访问属性 | 在保护派生类中的访问属性 |
---|---|---|---|
私有成员 | 不可直接访问 | 不可直接访问 | 不可直接访问 |
公有成员 | 公有 | 私有 | 保护 |
保护成员 | 保护 | 私有 | 保护 |
内部访问:有派生类中的新增成员函数对基类继承来的成员的访问
对象访问:在派生类外部,通过派生类的对象对从基类继承来的成员的访问
基类中的成员 | 私有成员 | 公有成员 | 保护成员 |
---|---|---|---|
内部访问 | 不可访问 | 可访问 | 可访问 |
外部访问 | 不可访问 | 不可访问 | 不可访问 |
基类中的成员 | 私有成员 | 公有成员 | 保护成员 |
---|---|---|---|
内部访问 | 不可访问 | 可访问 | 可访问 |
外部访问 | 不可访问 | 可访问 | 不可访问 |
基类中的成员 | 私有成员 | 公有成员 | 保护成员 |
---|---|---|---|
内部访问 | 不可访问 | 可访问 | 可访问 |
外部访问 | 不可访问 | 不可访问 | 不可访问 |
当创建派生类对象时,首先执行基类的构造函数,后调用派生类的构造函数的顺序执行。析构函数的调用顺序与构造函数的调用顺序正好相反,先调用派生类的析构函数,后调用基类的析构函数。
派生类名 (参数总表): 基类名(参数表)
{
派生类新增数据成员的初始化语句
}
派生类名 (参数总表)中包括参数的类型和参数名
基类名(参数表)中只有参数名,没有类型,因为这里是调用基类构造函数,这些参数是实参,可以为派生类构造函数总参数中的参数,也可以是常量或全局部变量
当派生类中含有内嵌的对象成员(子对象)时:
派生类名 (参数总表): 基类名(参数表0),对象成员名1(参数表1),......
{
派生类新增数据成员的初始化语句
}
定义派生类对象时,,构造函数的执行顺序:
派生类可以声明与基类成员同名的成员。在没有虚函数的情况下,如果在派生类中定义了与基类成员同名的成员,则称派生类成员覆盖了基类的同名成员,在派生类中使用这个名字意味着访问在派生类中声明的成员。为了在派生类中使用与基类同名的成员,必须在该成员名之前加上基类名和作用域标识符“::”,即
基类名::成员名
class X{
public:
int f();
};
class Y:public X{
public:
int f();
void q();
};
void Y::q()
{ f(); //表示访问派生类中的f(),即Y::f()
X::f(); //表示访问基类中的f()
}
Y obj;
obj,f(); //表示访问派生类中的f(),即Y::f()
obj.X::f();
访问声明的方法就是把基类的保护成员或共有成员直接写在私有派生类定义式中的同名段中,同时给成员名前冠以基类名和作用域标识符“::”。利用这种方法,该成员就成为派生类的保护成员或共有成员了。
class B:private A{
public: //
.....
A::print; //printA中的函数
......
};
class 派生类名:继承方式1 基类名1,.......,继承方式n 基类名n{
派生类新增的数据成员和成员函数
};
//不写继承方式则默认是private
派生类名 (参数总表): 基类名1(参数表1),基类名2(参数表2),......,基类名n(参数表n)
{
派生类新增成员的初始化语句
}
虚基类在派生类中的声明 //用在中间的类,base,base1,base2,derved,在base1,base2需要
class 派生类名:virtual 继承方式 基类名{
...}
#include <iostream>
#include <string>
using namespace std;
class Base{
protected:
int a;
public:
Base(){
a = 5;
cout << "Base a = " << a << endl;
}
};
class Base1: public Base{
public:
Base1() {
a = a + 10;
cout << "Base1 a = " << a << endl;
}
};
class Base2: public Base{
public:
Base2() {
a = a + 20;
cout << "Base2 a = " << a << endl;
}
};
class Derived: public Base1, public Base2{
public:
Derived() {
cout
文章浏览阅读1.6k次。安装配置gi、安装数据库软件、dbca建库见下:http://blog.csdn.net/kadwf123/article/details/784299611、检查集群节点及状态:[root@rac2 ~]# olsnodes -srac1 Activerac2 Activerac3 Activerac4 Active[root@rac2 ~]_12c查看crs状态
文章浏览阅读1.3w次,点赞45次,收藏99次。我个人用的是anaconda3的一个python集成环境,自带jupyter notebook,但在我打开jupyter notebook界面后,却找不到对应的虚拟环境,原来是jupyter notebook只是通用于下载anaconda时自带的环境,其他环境要想使用必须手动下载一些库:1.首先进入到自己创建的虚拟环境(pytorch是虚拟环境的名字)activate pytorch2.在该环境下下载这个库conda install ipykernelconda install nb__jupyter没有pytorch环境
文章浏览阅读5.2k次,点赞19次,收藏28次。选择scoop纯属意外,也是无奈,因为电脑用户被锁了管理员权限,所有exe安装程序都无法安装,只可以用绿色软件,最后被我发现scoop,省去了到处下载XXX绿色版的烦恼,当然scoop里需要管理员权限的软件也跟我无缘了(譬如everything)。推荐添加dorado这个bucket镜像,里面很多中文软件,但是部分国外的软件下载地址在github,可能无法下载。以上两个是官方bucket的国内镜像,所有软件建议优先从这里下载。上面可以看到很多bucket以及软件数。如果官网登陆不了可以试一下以下方式。_scoop-cn
文章浏览阅读4.5k次,点赞2次,收藏3次。首先要有一个color-picker组件 <el-color-picker v-model="headcolor"></el-color-picker>在data里面data() { return {headcolor: ’ #278add ’ //这里可以选择一个默认的颜色} }然后在你想要改变颜色的地方用v-bind绑定就好了,例如:这里的:sty..._vue el-color-picker
文章浏览阅读640次。基于芯片日益增长的问题,所以内核开发者们引入了新的方法,就是在内核中只保留函数,而数据则不包含,由用户(应用程序员)自己把数据按照规定的格式编写,并放在约定的地方,为了不占用过多的内存,还要求数据以根精简的方式编写。boot启动时,传参给内核,告诉内核设备树文件和kernel的位置,内核启动时根据地址去找到设备树文件,再利用专用的编译器去反编译dtb文件,将dtb还原成数据结构,以供驱动的函数去调用。firmware是三星的一个固件的设备信息,因为找不到固件,所以内核启动不成功。_exynos 4412 刷机
文章浏览阅读2w次,点赞24次,收藏42次。Linux系统配置jdkLinux学习教程,Linux入门教程(超详细)_linux配置jdk
文章浏览阅读3.3k次,点赞5次,收藏19次。xlabel('\delta');ylabel('AUC');具体符号的对照表参照下图:_matlab微米怎么输入
文章浏览阅读119次。顺序读写指的是按照文件中数据的顺序进行读取或写入。对于文本文件,可以使用fgets、fputs、fscanf、fprintf等函数进行顺序读写。在C语言中,对文件的操作通常涉及文件的打开、读写以及关闭。文件的打开使用fopen函数,而关闭则使用fclose函数。在C语言中,可以使用fread和fwrite函数进行二进制读写。 Biaoge 于2024-03-09 23:51发布 阅读量:7 ️文章类型:【 C语言程序设计 】在C语言中,用于打开文件的函数是____,用于关闭文件的函数是____。
文章浏览阅读3.4k次,点赞2次,收藏13次。跟随鼠标移动的粒子以grid(SOP)为partical(SOP)的资源模板,调整后连接【Geo组合+point spirit(MAT)】,在连接【feedback组合】适当调整。影响粒子动态的节点【metaball(SOP)+force(SOP)】添加mouse in(CHOP)鼠标位置到metaball的坐标,实现鼠标影响。..._touchdesigner怎么让一个模型跟着鼠标移动
文章浏览阅读178次。项目运行环境配置:Jdk1.8 + Tomcat7.0 + Mysql + HBuilderX(Webstorm也行)+ Eclispe(IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持)。项目技术:Springboot + mybatis + Maven +mysql5.7或8.0+html+css+js等等组成,B/S模式 + Maven管理等等。环境需要1.运行环境:最好是java jdk 1.8,我们在这个平台上运行的。其他版本理论上也可以。_基于java技术的停车场管理系统实现与设计
文章浏览阅读3.5k次。前言对于MediaPlayer播放器的源码分析内容相对来说比较多,会从Java-&amp;gt;Jni-&amp;gt;C/C++慢慢分析,后面会慢慢更新。另外,博客只作为自己学习记录的一种方式,对于其他的不过多的评论。MediaPlayerDemopublic class MainActivity extends AppCompatActivity implements SurfaceHolder.Cal..._android多媒体播放源码分析 时序图
文章浏览阅读2.4k次,点赞41次,收藏13次。java 数据结构与算法 ——快速排序法_快速排序法