C++：函数

函数参数的传递机制

C++的每个程序至少有一个函数，即主函数main()，函数也是类的方法的实现手段。C++的函数包括两类：预定于函数和用户自定义函数。

函数的定义格式为：

<返回值类型><函数名>(<参数列表>)

<函数体>

其中，<返回值类型>实值函数返回值的数据类型，可以是任意一种基本数据类型或用户自定义数据类型，以及类类型。<函数名>是给函数指定的名字，函数名应遵循标识符的命名规定。<参数列表>是指参数的个数、名称和类型，函数定义中的参数成为形参。<函数体>实值函数完成的功能，由说明语句和执行语句组成。

在C++语言中，函数的参数传递有三种方式：按变量值传递、按变量的地址传递和引用传递。C++语言可以用简单变量作为参数进行传递，也可以将对象作为参数传递给函数，其方法与传递其他类型的数据一样。

使用对象作为函数参数

对象作为函数参数时，其参数传递机制与其他类型的数据作为函数参数相同。在进行函数调用时，可将实参对象的值复制一份给对应的形参对象。因此，作为形参的对象，其数据的改变并不会影响实参对象。

实例

#include "iostream"
using namespace std;
class Point{
public:Point(int a, int b):x(a),y(b){}void Move(Point p){p.x = p.x + 1;p.y = p.y + 1;}void Print(){cout << "x:" << x << ", y:" << y << endl;}
private:int x, y;
};int main(){Point p1(1, 2);cout << "before move:";p1.Print();p1.Move(p1);cout << "after  move:";p1.Print();return 0;
}

运行结果：

before move:x:1, y:2
after  move:x:1, y:2

使用对象指针作为函数参数

在进行函数调用时，以对象指针作为参数，其实质是传地址调用，即参数与实参共享同一内存单元。因此，作为形参的对象，其数据的改变将影响实参对象，从而实现函数之间的信息传递。此外，使用对象指针作为参数仅将对象的地址传递给形参，而不进行副本的复制，可以提高运行效率，减少时空开销。

实例

#include "iostream"
using namespace std;
class Point{
public:Point(int a, int b):x(a),y(b){}void Move(Point *p){(*p).x = (*p).x + 1;//也可以写成p->x=p->x + 1(*p).y = (*p).y + 1;}void Print(){cout << "x:" << x << ", y:" << y << endl;}
private:int x, y;
};int main(){Point p1(1, 2);cout << "before move:";p1.Print();p1.Move(&p1);cout << "after  move:";p1.Print();return 0;
}

运行结果

before move:x:1, y:2
after  move:x:1, y:2

使用对象引用作为函数参数

用对象引用作为函数参数不但具有用对象指针作为函数参数的优点，而且相比之下，用对象引用作为函数参数可更简单、更直接。

实例

#include "iostream"
using namespace std;
class Point{
public:Point(int a, int b):x(a),y(b){}void Move(Point &p){p.x = p.x + 1;p.y = p.y + 1;}void Print(){cout << "x:" << x << ", y:" << y << endl;}
private:int x, y;
};int main(){Point p1(1, 2);cout << "before move:";p1.Print();p1.Move(p1);cout << "after  move:";p1.Print();return 0;
}

运行结果

before move:x:1, y:2
after  move:x:1, y:2

三种传递方式比较

  1. 适用对象作为函数参数。当进行函数调用时，需要给形参分配存储单元，形参和实参的结合是值传递，实参将自己的值传递给形参，形参实际上是实参的副本。这是一种单向传递，形参的变化不会影响到实参。
  2. 使用指针作为函数参数。当进行函数调用时，需要给形参分配存储单元，形参和实参的结合是地址传递，实参将自己的地址传递给形参。这是一种双向传递，形参的变化会直接影响带实参。缺点是阅读性较差。
  3. 使用引用作为函数参数。当进行函数调用时，在内存中并没有产生实参的副本，它是直接对实参操作。这种方式是双向传递，形参的变化会直接影响到实参。与指针作为函数参数相比，它更容易使用、更清晰。当参数传递的数据较大时，用引用比一般变量传递参数的效率要高，所占用空间更少。

内联函数

在程序设计中，效率是一个很重要的指标。在C语言中，保护效率的一个方法是使用宏(Macro)。宏可以不用函数调用，但看起来像函数调用。宏是用预处理器来实现的。预处理器直接用宏代码代替宏调用，因此就不需要函数调用所需的保存调用时的现场状态和返回地址、进行参数传递等的时间花费。然而C++的预处理器不允许存取私有数据，这意味着预处理器宏在用作成员函数时变得非常无用。为了既保持预处理器宏的效率又增加安全性，而且还能像一般成员函数一样可以在类里访问自如，C++引入了内联函数(Inline Function)。内联函数时一个函数，它与一般函数的区别是，在使用时可以像宏一样展开，所以没有函数调用的开销。因此，使用内联函数可以提高系统的执行效率。但在内联函数体中，不能含有复杂的结构控制语句，如语句switch和while等。内联函数实际是一种空间换时间的方案，因此其缺点是增大了系统空间方面的开销。在类内给出函数体定义的成员函数被默认为内联函数。

内联函数的定义格式为：inline 返回值类型 函数名(形式参数表){//函数体}

例如：大小写字母转换

#include "iostream"
using namespace std;
inline char Trans(char ch){if(ch >= 'a' && ch <= 'z') return ch - 32;else return ch + 32;
}int main(){char ch;while((ch = getchar()) != '\n')cout << Trans(ch);cout << endl;return 0;
}

【注】

  1. 内联函数代码不宜太长，一般是1~5行代码，而且不能含有复杂的分支或循环语句等。
  2. 在类内定义的成员函数默认为内联函数。
  3. 在类外给出函数体的成员函数，若要定义为内联函数，则必须加上关键字inline。否则，编译器将它作为普通成员函数。
  4. 递归调用的函数不能定义为内联函数。

函数重载

函数名可以看作一个操作的名字。当多个函数实现的是同一类功能，只是部分细节不同（如参数的个数或参数类型不同）时，C++提供了函数重载机制，即将这些函数取成相同的名字，从而时程序已于阅读和理解，方便记忆和使用。

函数重载实质两个或两个以上的函数具有相同的函数名，但其参数类型不一致或参数个数不同。函数重载包括非成员函数的重载和成员函数重载。

非成员函数重载

非成员函数重载是指对用户所编写的那些功能相同或类似、参数个数或类型不同的用户自定义函数，C++可以采用相同的函数名，从而提高程序的可读性。支持函数重载时C++多态性的体现之一。

例如：求两个数的积

#include "iostream"
using namespace std;
int Mul(int x, int y){return x * y;
}
double Mul(double x, double y){return x * y;
}int main(){int x, y;double a, b;cout << "input x, y:";cin >> x >> y;cout << "x*y=" << Mul(x, y) << endl;cout << "input a, b:";cin >> a >> b;cout << "a*b=" << Mul(a, b) << endl;return 0;
}

【注】

  1. 重载函数必须具有不同的参数个数或不同的参数类型，若只是返回值的类型不同或参数名不同时不行的。

  2. 重载函数应满足：函数名相同，函数的返回值类型可以相同也可以不同，当各函数的参数表中的参数个数或类型必须有所不同，这样才能进行区分，从而正确地调用函数。

  3. 匹配重载函数的顺序：a.通过内部类型转换寻求一个匹配，若找到，则调用该函数；b.通过强制类型转换寻求一个匹配，若找到，则调用函数。

  4. 不能将不同功能的函数定义为重载函数，以免产生误解。

  5. 创建重载函数时，必须让编译器能区分两个（或更多）的重载函数。当创建的多个重载函数编译器不能区分时，编译器就认为这些函数具有多义性，即调用是错误的，编译器不会编译该程序。例如：

    #include "iostream"
using namespace std;
float Mul(float x){return 2 * x;
}
double Mul(double x){return 2 * x;
}int main(){cout << Mul(10.2) << endl;cout << Mul(10) << endl;//错误。产生二义性return 0;
}

    报错

    error: call of overloaded 'Mul(int)' is ambiguous400 |     cout << Mul(10) << endl;//错误。产生二义性
|             ~~~^~~~note: candidate: 'float Mul(float)'391 | float Mul(float x){|       ^~~note: candidate: 'double Mul(double)'394 | double Mul(double x){|        ^~~

  6. 当函数的重载带有默认参数值时，要避免产生二义性。

成员函数重载

成员函数重载主要是为了适应相同成员函数的参数多样性。成员函数重载的一个很重要的应用就是重载构造函数。因为构造函数的名字预先有类的名字确定，所以只能有一个构造函数名。但在解决实际问题时，可能会需要创建具有不同形态的对象，因此，C++提供了函数重载机制。通过对构造函数进行重载，可以实现定义对象时初始化赋值的多样性。但是析构函数不能重载，因为一个类中只允许有且仅有一个析构函数。

例如：求了两个复数的和

#include "iostream"
using namespace std;
class Complex{
public:Complex(double r, double i):real(r),imag(i){}Complex(double r):real(r),imag(0){}Complex():real(0),imag(0){}Complex Add(Complex a){Complex temp;temp.real = real + a.real;temp.imag = imag + a.imag;return temp;}void Print(){cout << real;if(imag > 0) cout << "+";if(imag != 0) cout << imag << "i" << endl;}
private:double real, imag;
};int main(){Complex com1(1.1, 2.2), com2(3.3, 4.4), com3(5.5), total;total = com1.Add(com2);total.Print();total = com1.Add(com3);total.Print();return 0;
}

运行结果：

4.4+6.6i
6.6+2.2i

函数的默认参数值

  1. 当函数既有声明和定义时，默认参数值只能在声明中指定，不能再函数定义中指定。

    void Fun(int x = 0, int y = 0);//正确，在函数声明中指定默认参数值
void Fun(int x = 0, int y = 0){ // ....} //错误，不能再函数定义中指定默认参数值

  2. 在函数声明中，所有带默认值的参数都必须出现再没有默认值参数的右边。也就是说，一旦开始定义带默认值的参数，在其后面就不能再定义没有默认值的参数了。例如：

    void Fun(int i, int j = 0, int k); //错误

  3. 在函数调用时，若某个参数省略，则其后面的参数皆应省略而采用默认参数值。例如：

    Fun(,9);//错误的调用

  4. 当重载函数带有默认参数值时，要注意避免二义性。

友元

类的主要特点之一是数据隐藏，类的私有成员或保护成员只能通过其成员函数来访问。那么有没有办法允许再类外对某个对象的私有成员或保护成员进行操作？C++中提供了友元机制来解决这个问题。

友元函数

友元函数不是当前类中的成员函数，它不仅可以是一个不属于任何一个类的一般函数（非成员函数），也可以是另外一个类的成员函数。当函数被声明为一个类的友元函数后，它就可以通过对象名访问类的私有成员和保护成员。

非成员函数作为友元函数

非成员函数作为类的友元函数后，就可以通过对象访问封装再类内部的数据。声明友元函数的方法是，在类的定义中用关键字friend进行声明，格式为：friend 函数返回值 函数名(形参表);

例如：使用友元函数将百分制学生的成绩转换成相应的分数等级。

#include "iostream"
#include "iomanip"
#include "cstring"using namespace std;
class Student{
public:Student(char na[], int sco){strcpy_s(name, strlen(na) + 1, na);score = sco;}friend void Trans(Student *s){if (s->score >= 90) strcpy_s(s->level, strlen("优") + 1, "优");else if(s->score >= 80) strcpy_s(s->level, strlen("良") + 1,"良");else if(s->score >= 70) strcpy_s(s->level, strlen("中") + 1,"中");else if(s->score >= 60) strcpy_s(s->level, strlen("及格") + 1,"及格");else  strcpy_s(s->level, strlen("不及格") + 1,"不及格");}void Print(){cout << name << setw(10) << score << setw(8) << level << endl;}
private:char name[10];int score;char level[7];
};int main(){Student stu[] = {Student("李明", 76), Student("李华", 82), Student("王明", 96), Student("星星", 52)};cout << "输出结果：" << endl;cout << "姓名" << setw(10) << "成绩" << setw(8) << "等级" << endl;for(int i = 0; i< 4; i++){Trans(&stu[i]);stu[i].Print();}return 0;
}

运行结果

输出结果：
姓名      成绩    等级
李明        76      中
李华        82      良
王明        96      优
星星        52  不及格

【注】

  1. 非成员函数成为类的友元函数后，若再类外定义，则不能再函数名前加”类名::“，因为他不是该类的成员函数；非成员函数作为类的友元函数没有this指针；调用友元函数时必须在其实参标中给出要访问的对象。

  2. 友元函数既可以在类的私有部分进行声明，也可以再类的公有部分进行声明。

  3. 当一个函数需要访问多个类时，应该把这个函数同时定义为这些类的友元函数，这样，该函数才能访问这些类的私有或保护成员，例如。

    #include "iostream"
using namespace std;
class Time;
class Date{
private:int year, month, day;
public:Date(int y, int m, int d):year(y),month(m),day(d){}friend void Calcutetime(Date d, Time t);
};
class Time{
private:int hour, minute, second;
public:Time(int h, int m, int s):hour(h),minute(m),second(s){}friend void Calcutetime(Date d, Time t);
};
void Calcutetime(Date d, Time t){int mom[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};int days = d.day, total;for(int i = 1; i < d.month; i++){days = days + mom[i - 1];}if((d.year % 4 == 0 && d.year % 100 != 0 || d.year % 400 == 0) && d.month >= 3) days = days + 1;total = ((days * 24 + t.hour) * 60 + t.minute) * 60 + t.second;cout << d.year << "-" << d.month << "-" << d.day << "    ";cout << t.hour << ":" << t.minute << ":" << t.second << endl;cout << "total time:   " << total << "   seconds" << endl;
}
int main(){Date d(2018, 11, 13);Time t(14, 20, 25);Calcutetime(d, t);return 0;
}

  4. 若友元函数带了两个不同的类的对象，其中一个对象所对应的类要在后面声明。

类的成员函数作为友元函数

一个类的成员函数可以作为另一个类的友元函数，这种成员函数不仅可以访问自己所在类中的成员，还可以通过对象名访问friend声明语句所在类的私有成员和保护成员，从而使两个类相互合作。

#include "iostream"
using namespace std;
class Time;
class Date{
private:int year, month, day;
public:Date(int y, int m, int d):year(y),month(m),day(d){}void Calcutetime(Time t);
};
class Time{
private:int hour, minute, second;
public:Time(int h, int m, int s):hour(h),minute(m),second(s){}friend void Date::Calcutetime(Time t);
};
void Date::Calcutetime(Time t){int mom[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};int days = day, total;for(int i = 1; i < month; i++){days = days + mom[i - 1];}if((year % 4 == 0 && year % 100 != 0 || year % 400 == 0) && month >= 3) days = days + 1;total = ((days * 24 + t.hour) * 60 + t.minute) * 60 + t.second;cout << year << "-" << month << "-" << day << "    ";cout << t.hour << ":" << t.minute << ":" << t.second << endl;cout << "total time:   " << total << "   seconds" << endl;
}
int main(){Date d(2018, 11, 13);Time t(14, 20, 25);d.Calcutetime(t);return 0;
}

友元类

友元函数可以使函数能够访问某个类中的私有或保护成员。若类A的所有成员函数都想访问类B的私有或保护成员，一种方法使将类A的所有成员函数都声明为类B的友元函数，但这样会让程序显得冗余。为此，C++提供了友元类。一个类也可以作为另一个类的友元类。若类A声明为类B的友元类，则类A中的每个成员函数都具有访问类B的保护或私有数据成员的特权，方法如下：

class A{//.....void fa();
};
class B{//.....friend class A;
};

例如：将一个复数转换为二维向量

#include "iostream"
using namespace std;
class Complex{
private:double real, imag;
public:Complex(double r, double i):real(r),imag(i){}friend class Vector;
};
class Vector{
private:double x, y;
public:void Change(Complex c){x = c.real;y = c.imag;}void Print(Complex c){cout << "复数：" << c.real;if(c.imag > 0) cout << "+";cout << c.imag << "i" << endl;cout << "二维向量：" << "(" << x << "," << y << ")" << endl;}
};
int main(){Complex c(1.2, 3.4);Vector v;v.Change(c);v.Print(c);return 0;
}

【注】：友元关系是单向的。若类A是类B的友元，则类A中的所有成员函数都可以直接访问类B的保护或私有数据成员。但反过来，类B中的所有成员函数不能访问类A中的保护和私有成员。友元关系不能进行传递。友元在声明时即可以放在类的私有部分，也可以放在类的公有部分。

静态成员

C++允许在函数内部创建一个static对象，这个对象将存储在程序的静态数据区中，而不是在堆栈中，它只在函数第一次调用时初始化一次，以后将在两次函数之间保持其值。

静态数据成员

当声明一个类后，考研建立该类的多个对象，每个对象都有类中所定义数据成员的拷贝，对应不同的存储空间，各个对象相互独立，实现了数据的封装与隐藏。但在有些情况下，类中的某个数据成员是该类所有对象所共有的，若采用数据成员的定义方法，则不能实现数据成员的共享。C++为此提供了静态数据成员，类的静态数据成员拥有一块单独的存储区，不管用户创建了多少个对象，所有这些对象的静态数据成员都共享这块静态存储区，进而为这些对象提供了一种互相通信的方法。

静态数据成员的定义格式为：static 类型名 静态成员名;

静态数据成员的初始化格式：类型 类名::静态数据成员=初始化值;

例如

#include "iostream"
#include "iomanip"
#include "cstring"using namespace std;
class Student{
private:char *name;int no;float score;static int total;//定义静态数据成员
public:Student(char *na, int sno, float sco):no(sno),score(sco){name = new char(strlen(na) + 1);strcpy_s(name, strlen(na) + 1, na);total++;}~Student(){delete []name;}void Print(){cout << "第" << total << "个学生：" << name << setw(4) << no << setw(4) << score << endl;cout << "总学生人数：" << total << endl;}
};
int Student::total = 0;//初始化静态数据成员
int main(){Student s1("张明", 1, 90);s1.Print();Student s2("张三", 2, 85);s2.Print();return 0;
}

运行结果：

第1个学生：张明   1  90
总学生人数：1
第2个学生：张三   2  85
总学生人数：2

【注】

  1. 静态数据成员的声明需加关键字static，访问格式：类名::静态数据成员名
  2. 静态数据成员的初始化应在类外生命并在对象生成之前进行。默认时，静态成员被初始化为零。
  3. 静态数据成员在编译时创建并初始化，不能用构造函数进行初始化。静态数据成员不能再任何函数内分配存储空间和初始化。

静态成员函数

与静态数据成员一样，用户也可以创建静态成员函数，静态成员函数不能访问一般的数据成员和成员函数，它只能访问静态数据成员和其他的静态成员函数。静态成员函数时独立于类对象而存在的，因此没有this指针。

静态成员函数的定义格式为：static 返回类型 静态成员函数名(参数表);

调用格式为：类名::静态成员函数名(实参表);

静态对象

在定义对象时，可以定义类的静态对象，静态对象的析构函数是在主函数结束时才自动执行的，与普通对象相同，静态对象的析构函数和构造函数的执行顺序相反。

静态对象定义格式：static 类名 静态对象名;

例如：

#include "iostream"
#include "iomanip"
#include "cstring"using namespace std;
class Student{
private:char name[10];
public:Student(char na[]){strcpy_s(name, strlen(na) + 1, na);cout << "inside construct:" << name << endl;}~Student(){cout << "inside destruct:" << name << endl;}
};
void Fun(){static Student s2("Student B");Student s3("Student C");
}
Student s1("Student A");
int main(){cout << "inside main" << endl;Fun();Fun();cout << "outside main" << endl;return 0;
}

运行结果：

inside construct:Student A
inside main
inside construct:Student B
inside construct:Student C
inside destruct:Student C
inside construct:Student C
inside destruct:Student C
outside main
inside destruct:Student B
inside destruct:Student A

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

深入解析：树结构及其应用

深入解析：树结构及其应用

文章目录 学习树的基本概念理解树的遍历方式学习堆和优先队列的应用案例分析&#xff1a;使用堆进行Top K元素的查找结论 &#x1f389;欢迎来到数据结构学习专栏~深入解析&#xff1a;树结构及其应用 ☆* o(≧▽≦)o *☆嗨~我是IT陈寒&#x1f379;✨博客主页&#xff1a;IT陈…
阅读更多...
Python HTML解析新玩法：掌握BeautifulSoup4从入门到精通

Python HTML解析新玩法：掌握BeautifulSoup4从入门到精通

介绍 BeautifulSoup4是Python中一个强大的第三方库&#xff0c;用于解析HTML和XML文档&#xff0c;并提供了简单又灵活的方式来遍历文档树、搜索文档元素以及提取所需信息。BeautifulSoup4的功能使得在Python中进行网页数据抓取和解析变得非常方便。本文将从入门到精通地介绍B…
阅读更多...
556、Vue 3 学习笔记 -【常用Composition API（五）】 2023.08.25

556、Vue 3 学习笔记 -【常用Composition API（五）】 2023.08.25

目录 一、生命周期二、自定义hook函数三、toRef四、参考链接 一、生命周期 Vue3中可以继续使用Vue2中的生命周期钩子&#xff0c;但有两个被更名&#xff1a; beforeDestroy改名为beforeUnmountdestroy改名为unmounted Vue3也提供了组合式API形式的生命周期钩子&#xff0c;…
阅读更多...
Redis三种持久化方式详解

Redis三种持久化方式详解

一、Redis持久性 Redis如何将数据写入磁盘 持久性是指将数据写入持久存储&#xff0c;如固态磁盘&#xff08;SSD&#xff09;。Redis提供了一系列持久性选项。其中包括&#xff1a; RDB&#xff08;快照&#xff09;&#xff1a;RDB持久性以指定的时间间隔执行数据集的时间点…
阅读更多...
前端Vue3框架知识点大全

前端Vue3框架知识点大全

Vue.js是一种流行的JavaScript前端框架&#xff0c;它的第三个版本Vue3带来了许多令人兴奋的新特性和改进。 1、响应式数据&#xff1a; Vue 3采用了基于Proxy的响应式系统&#xff0c;相比Vue 2中的Object.defineProperty&#xff0c;Proxy提供了更强大和灵活的拦截器&#…
阅读更多...
【AUTOSAR】【CAN通信】CanNm

【AUTOSAR】【CAN通信】CanNm

目录 一、概述 二、说明 三、功能说明 3.1 协调算法 3.2 操作模式 3.2.1 网络模式
阅读更多...
Stable Diffusion 系列教程 | 如何获得更高清优质的AI绘画

Stable Diffusion 系列教程 | 如何获得更高清优质的AI绘画

目录 1 高清修复 1.1 原理 1.2 基本操作 1.3 优缺点 2 UpScale 放大脚本 2.1 原理 2.2 基本操作 2.3 优缺点 3 附加功能放大 3.1 原理 3.2 基本操作 3.3 优缺点 优化出图质量&#xff0c;产出更高清&#xff0c;分辨率更高&#xff0c;更有细节的绘画作品呢&#x…
阅读更多...
B. Burning Midnight Oil

B. Burning Midnight Oil

Problem - B - Codeforces 问题描述&#xff1a;给定n和k&#xff0c;求满足以下条件的最小的v。 n ≥ ∑ i 0 ∞ [ v k i ] n \ge \sum_{i0}^{\infty}[ \frac v {k^i}] n≥i0∑∞​[kiv​] 具有单调性&#xff0c;用二分。二分答案&#xff0c;最大值最小。 代码&#xff…
阅读更多...
Nexus 如何配置匿名用户访问一个仓库

Nexus 如何配置匿名用户访问一个仓库

现在有这样一个需求&#xff0c;我们需要匿名用户访问 Nexus 的一个公共仓库。 设置 Roles 在满足这个需求之前&#xff0c;我们需要设置一个 Roles。 Role 的名字是可以随填写的。 这里关键的问题在你需要访问的仓库的 View 的权限需要设置 Read 和 Browse 这 2 个权限。 如…
阅读更多...
08-信息收集-架构、搭建、WAF等

08-信息收集-架构、搭建、WAF等

信息收集-架构、搭建、WAF等 信息收集-架构、搭建、WAF等一、前言说明二、CMS识别技术三、源码获取技术四、架构信息获取技术五、站点搭建分析1、搭建习惯-目录型站点2、搭建习惯-端口类站点3、搭建习惯-子域名站点4、搭建习惯-类似域名站点5、搭建习惯-旁注&#xff0c;c段站点…
阅读更多...
OpenCV 中的色彩空间 (C++ / Python)

OpenCV 中的色彩空间 (C++ / Python)

在本教程中，我们将了解计算机视觉中使用的流行色彩空间，并将其用于基于颜色的分割。我们还将分享 C++ 和 Python 的演示代码。
阅读更多...
win10+wsl2+Ubuntu20.2+Pycharm+WSL解释器

win10+wsl2+Ubuntu20.2+Pycharm+WSL解释器

目的&#xff1a;创建一个ubuntu系统下的python解释器&#xff0c;作为win平台下的pycharm的解释器。 这样做的好处是可以直接在win系统里操作文件&#xff0c;相比于linux方便一点&#xff0c;而且也不用对wsl的子系统进行迁移。 一、安装前准备 1. 设置-Windows更新-window…
阅读更多...
SpringBoot项目集成ElasticSearch服务

SpringBoot项目集成ElasticSearch服务

本文已收录于专栏 《中间件合集》 目录 版本介绍背景介绍优势说明集成过程1.引入依赖2.添加配置文件3.初始化 示例说明代码结果 总结提升 版本介绍 Spring boot的版本是&#xff1a; 2.3.12   ElasticSearch的版本是&#xff1a;7.6.2 背景介绍 在我们的项目中经常会遇到对于…
阅读更多...
datax 删除分区数据，再写入MySQL脚本

datax 删除分区数据，再写入MySQL脚本

#! /bin/bashDATAX_HOME/opt/module/datax#1、判断参数是否传入 if [ $# -lt 1 ] thenecho "必须传入all/表名..."exit fi #2、判断日期是否传入 [ "$2" ] && datestr$2 || datestr$(date -d -1 day %F)#DataX导出路径不允许存在空文件&#xff0c…
阅读更多...
Unity - 特殊文件夹

Unity - 特殊文件夹

地址记录&#xff1a;https://www.cnblogs.com/zouqiang/p/6841399.html Assets Assets文件夹是unity项目中放置游戏资源的主文件夹。 该文件夹中的内容将直接反应在编辑器的Project视口中。许多系统API基于该文件夹路径。 Resources Unity允许你按需动态加载游戏资源到场景中…
阅读更多...
Python使用pyqt5写windows桌面应用实战教程

Python使用pyqt5写windows桌面应用实战教程

本篇文章主要讲解，Python使用pyqt5写windows桌面应用的详细实战教程文章，主要涵盖单个界面的布局构建说明，表单构建说明，数据交互构建说明以及可直接开发的简易多界面框架实例构建说明，能够让你很快的了解pyqt在python中的使用和构建方式，快速实现一个简单的windows桌面图…
阅读更多...
NTP相关问题

NTP相关问题

ntp协议的相关概念 ntp(时间同步协议)&#xff0c;用来在分布式时间服务器和客户端之间进行时间同步。NTP基于UDP报文进行传输&#xff0c;使用的UDP端口号是123. 使用NTP的目的是对网络内所有具有时钟的设备进行时间同步&#xff0c;是网络内所有设备的时钟保持一致&#xff0…
阅读更多...
【Java转Go】快速上手学习笔记（六）之网络编程篇一

【Java转Go】快速上手学习笔记（六）之网络编程篇一

目录 TCP一个简单案例server.go 服务端client.go 客户端 HTTPserver.go 服务端client.go 客户端 RPC一个很简单的示例server.go 服务端client.go 客户端 WebSocketserver.go 服务端client.go 客户端 完整代码server.go 服务端client.go 客户端 go往期文章笔记&#xff1a; 【J…
阅读更多...
在本地创建repository及上传至github

在本地创建repository及上传至github

文章目录 本地管理设定git的用户名与邮箱初始化添加修改提交修改设定分支问题一:error: insufficient permission for adding an object... 数据同步创建SSH keys创建并关联远程仓库上传改动至github问题二:Failed to connect to github.com port 443: Connection timed out问题…
阅读更多...
spring整合MybatisAOP整合PageHelper插件

spring整合MybatisAOP整合PageHelper插件

一&#xff0c;spring集成Mybatis的概念 Spring 整合 MyBatis 是将 MyBatis 数据访问框架与 Spring 框架进行集成&#xff0c;以实现更便捷的开发和管理。在集成过程中&#xff0c;Spring 提供了许多特性和功能&#xff0c;如依赖注入、声明式事务管理、AOP 等 它所带来给我们的…
阅读更多...
最新文章

Copyright @ 2022~2023