cpp_06_缺省构造_拷贝构造_拷贝赋值_初始化表

1  构造函数

1.1  构造函数可重载：

                构造函数可以通过形参表的差别化形成重载关系

                重载关系的构造函数，通过构造函数的实参类型进行匹配

                使用缺省参数可以减少构造函数重载的数量

// consover.cpp 构造函数的重载
#include <iostream>
using namespace std;class Human {
public:void getinfo( ) {cout << "姓名: " << m_name << ", 年龄: " << m_age << endl;}
/*  Human( ) {cout << "1. Human() --> ";m_age = 0;m_name = "无名";}Human( int age ) {cout << "2. Human(int) --> ";m_age = age;m_name = "无名";}*/Human( int age=0, const char* name="无名" ) {//使用缺省值，减少上2个重载构造函数cout << "3. Human(int,const char*) --> ";m_age = age;m_name = name;}
private:int m_age;string m_name;
};// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {Human h; // 定义h,利用h.Human()h.getinfo( );Human h2(22); // 定义h2,利用h2.Human(22)h2.getinfo( );Human h3(22,"张飞"); // 定义h3,利用h3.Human(22,"张飞")h3.getinfo( );return 0;
}

1.2  四类构造函数：

        构造函数本没有分类，按参数个数，可分为四类：

                多参构造函数                   //2参及以上

                无参（缺省）构造函数    //0参

                拷贝构造函数                  //单参

                类型转换构造函数           //单参

2  缺省构造函数

2.1  理论

        1）也称无参构造函数，但其未必真的没有任何参数：

              为一个有参构造函数的每个形参都提供一个缺省值，同样可以达到无参构造函数的效果。

        2）如果一个类没有定义任何构造函数，那么编译器会为其提供一个无参构造函数：

                对基本类型的成员变量进行定义，并初始化为随机数；

                对类类型的成员变量进行定义，调用相应类型的无参构造函数。

              （由此强烈建议，为每个类提供无参的构造函数，因为它可能作为另外类的成员变量）

        3）如果一个类定义了构造函数，无论这个构造函数是否带有参数，编译器都不再为这个类

              提供无参构造函数，

              但仍会对成员变量进行定义/初始化为随机数，程序员自己按需再赋值即可：

                            Human( int age=0, const char* name="无名" ) {
                                  //【int m_age;】定义m_age,初值为随机数
                                  //【string m_name;】定义m_name,利用m_name.string()
                                  m_age = age;
                                  m_name = name;
                            }

// defaultcons.cpp 缺省构造函数
#include <iostream>
using namespace std;class Human {
public:
//  如果类没有提供任何构造函数,编译器将提供一个无参的构造函数
/*  Human() {【int m_age;】定义m_age,初值为随机数【string m_name;】定义m_name,利用m_name.string()}*/Human( int age=0, const char* name="无名" ) {//【int m_age;】定义m_age,初值为随机数//【string m_name;】定义m_name,利用m_name.string()cout << "Human类缺省构造函数被调用" << endl;m_age = age;m_name = name;}void getinfo( ) {cout << "姓名: " << m_name << ", 年龄: " << m_age << endl;}
private:int m_age; // 基本类型的成员变量string m_name; // 类类型的成员变量
};// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {Human h; // 定义h,利用h.Human()-->h维护的内容为(无名,0)h.getinfo( );Human h2(22,"张飞"); // 定义h2,利用h2.Human(22,"张飞")-->h2维护的内容为(张飞,22)h2.getinfo();return 0;
}

 

2.2  缺省构造过程

        

       

2.3  缺省构造函数 必要性！

        强烈建议，为每个类提供无参的构造函数，因为它可能作为另外类的成员变量：

//hastodeflt.cpp
// 强烈建议大家在设计一个类时，给这个类提供一个无参构造函数,
//因为这个类对象非常有可能作为另一个的成员变量出现
#include <iostream>
using namespace std;class A { // 当前A类有无参构造 
public:A( int i=0 ) { m_i = i;}
private:int m_i;
};class Human {
public:Human( int age=0, const char* name="无名" ) {//【int m_age;】定义m_age,初值为随机数//【string m_name;】定义m_name,利用m_name.string()//【A m_a;】定义m_a,利用m_a.A()cout << "Human类缺省构造函数被调用" << endl;m_age = age;m_name = name;}void getinfo( ) {cout << "姓名: " << m_name << ", 年龄: " << m_age << endl;}
private:int m_age; // 基本类型的成员变量string m_name; // 类类型的成员变量A m_a; // 类类型的成员变量
};// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {Human h; // 定义h,利用h.Human()-->h维护的内容为(无名,0)h.getinfo( );Human h2(22,"张飞"); // 定义h2,利用h2.Human(22,"张飞")-->h2维护的内容为(张飞,22)h2.getinfo();return 0;
}

3  拷贝构造函数

3.1  理论

        what？ ①构造函数只有1个形参      ②且参数类型与类名相同。

        class  类名{

                类名( const  类名&  that ){ ... }   // const 和 & 非必须，有了更好

                                                                  // &提升效率，const变万能引用

        }; 

        1）作用：利用一个已定义的对象，来定义其同类型的副本对象，即对象克隆。

        2）如果一个类没有定义拷贝构造函数，那么编译器会为其提供一个默认拷贝构造函数。

              -对基本类型成员变量进行定义，并赋初值（按字节复制）；

              -对类类型成员变量进行定义，并调用相应类型的拷贝构造函数。

        3）如果自己定义了拷贝构造函数，编译器将不再提供默认拷贝构造函数，这时所有与成员复制有关的操作，都必须自己编写代码完成。

                    Human( const Human& that ) { 
                          //【int m_age;】定义m_age,初值为随机数   编译器完成
                          //【string m_name;】定义m_name,利用m_name.string()   编译器完成
                          cout << "Human类拷贝构造函数被调用" << endl;    //手写
                          m_age = that.m_age;        //手写
                          m_name = that.m_name;  //手写
                    }

        4）由3）可知，自己写的效率低。因定义和赋值，进行了2次赋值（用初始化表可规避）。

        5）若拷贝构造函数不能满足要求，需自己定义。

// copycons.cpp 拷贝构造函数
#include <iostream>
using namespace std;class Human {
public:
//  如果类没有提供任何构造函数,编译器将提供一个无参的构造函数
/*  Human() {【int m_age;】定义m_age,初值为随机数【string m_name;】定义m_name,利用m_name.string()}*/Human( int age=0, const char* name="无名" ) {//【int m_age;】定义m_age,初值为随机数//【string m_name;】定义m_name,利用m_name.string()cout << "Human类缺省构造函数被调用" << endl;m_age = age;m_name = name;}
//  如果类没有提供拷贝构造函数,编译器将提供一个默认的拷贝构造函数
/*  Human( const Human& that ) { 【int m_age=that.m_age;】定义m_age,初值为that.m_age【string m_name(that.m_name);】定义m_name,利用m_name.string(that.m_name)-->string类拷贝构造函数}*/Human( const Human& that ) { //【int m_age;】定义m_age,初值为随机数//【string m_name;】定义m_name,利用m_name.string()cout << "Human类拷贝构造函数被调用" << endl;m_age = that.m_age;m_name = that.m_name;}void getinfo( ) {cout << "姓名: " << m_name << ", 年龄: " << m_age << endl;}
private:int m_age; // 基本类型的成员变量string m_name; // 类类型的成员变量
};// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {Human h; // 定义h,利用h.Human()-->h维护的内容为(无名,0)h.getinfo( );Human h2(22,"张飞"); // 定义h2,利用h2.Human(22,"张飞")-->h2维护的内容为(张飞,22)h2.getinfo();Human h3(h2); // = h2; // 定义h3,利用h3.Human(h2)-->触发拷贝构造函数h3.getinfo();return 0;
}

3.2  拷贝构造过程

        

3.3  拷贝构造函数的调用时机

        一切出现对象克隆的情况，都会调用拷贝构造函数：

        1）用已定义对象作为同类型对象的构造实参 

        2）以对象的形式向函数传递参数 

        3）从函数中返回对象 

        注意：某些拷贝构造过程会因编译优化而被省略。

// copytime.cpp 拷贝构造函数被调用的时间点
#include <iostream>
using namespace std;class Human {
public:Human( int age=0, const char* name="无名" ) {//【int m_age;】定义m_age,初值为随机数//【string m_name;】定义m_name,利用m_name.string()m_age = age;m_name = name;}Human( const Human& that ) { //【int m_age;】定义m_age,初值为随机数//【string m_name;】定义m_name,利用m_name.string()cout << "Human类拷贝构造函数被调用" << endl;m_age = that.m_age;m_name = that.m_name;}void getinfo( ) {cout << "姓名: " << m_name << ", 年龄: " << m_age << endl;}
private:int m_age; // 基本类型的成员变量string m_name; // 类类型的成员变量
};
// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
void foo( Human v ) {// ...
}
Human bar( ) {Human m;return m; // 利用m克隆一个无名对象
}
int main( void ) {Human h2(22,"张飞");Human h3(h2); // = h2; // (1)触发拷贝构造函数foo( h3 ); // (2)触发拷贝构造函数Human h4 = /*|...|*/ bar(); // 会触发2次拷贝构造函数，但编译器优化为0次// -fno-elide-contructors   不让编译器优化return 0;
}

4  拷贝构造与拷贝赋值的区别

        拷贝构造函数的对象是新创建的， 最好用初始化表

        拷贝赋值函数的对象是已有的，    不能用初始化表

5  拷贝赋值函数（不是构造函数）

5.1  理论

        what？  ① operator=    ② 参数只有一个  ③ 参数类型与类名相同

        class  类名{

                类名&  operator=( const  类名&  that ) { ... }  // &提升传参效率，const变万能引用

        };

        1）作用：用于一个已定义存在的对象，给已存在的同类型对象赋值，即对象赋值。

        2）如果一个类没有定义拷贝赋值函数，那么编译器会为其提供一个默认拷贝赋值函数。

                -对基本类型成员变量，值传递（按字节复制）

                -对类类型成员变量，调用相应类型的拷贝赋值函数。

        3）如果自己定义了拷贝赋值函数，编译器将不再提供默认拷贝赋值函数，这时所有与成员复制有关的操作，都必须自己写代码完成。（编译器也不会在自定义的函数中定义成员变量/包子馅，因为这不是构造函数。成员变量早就有了。）

        4）若默认拷贝赋值函数不能满足要求时，需自己定义。

// copyassignment.cpp 拷贝赋值函数:用于 对象之间的赋值
#include <iostream>
using namespace std;class Human {
public:
//  如果类没有提供任何构造函数,编译器将提供一个无参的构造函数
/*  Human() {【int m_age;】定义m_age,初值为随机数【string m_name;】定义m_name,利用m_name.string()}*/Human( int age=0, const char* name="无名" ) {//【int m_age;】定义m_age,初值为随机数//【string m_name;】定义m_name,利用m_name.string()cout << "Human类缺省构造函数被调用" << endl;m_age = age;m_name = name;}
//  如果类没有提供拷贝构造函数,编译器将提供一个默认的拷贝构造函数
/*  Human( const Human& that ) { 【int m_age=that.m_age;】定义m_age,初值为that.m_age【string m_name(that.m_name);】定义m_name,利用m_name.string(that.m_name)-->string类拷贝构造函数}*/Human( const Human& that ) { //【int m_age;】定义m_age,初值为随机数//【string m_name;】定义m_name,利用m_name.string()cout << "Human类拷贝构造函数被调用" << endl;m_age = that.m_age;m_name = that.m_name;}
//  如果类没有提供拷贝赋值函数,编译器将提供一个默认的拷贝赋值函数
/*  Human& operator=( const Human& that ) {this->m_age = that.m_age;this->m_name = that.m_name; // this->m_name.operator=(that.m_name)-->// string类的拷贝赋值函数return *this;}*/Human& operator=( const Human& that ) {// 编译器不会再拷贝赋值函数中塞任何操作cout << "Human类的拷贝赋值函数被调用" << endl;this->m_age = that.m_age;this->m_name = that.m_name; // this->m_name.operator=(that.m_name)-->// string类的拷贝赋值函数return *this;}void getinfo( ) {cout << "姓名: " << m_name << ", 年龄: " << m_age << endl;}
private:int m_age; // 基本类型的成员变量string m_name; // 类类型的成员变量
};// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {Human h; // 定义h,利用h.Human()-->h维护的内容为(无名,0)h.getinfo( );Human h2(22,"张飞"); // 定义h2,利用h2.Human(22,"张飞")-->h2维护的内容为(张飞,22)h2.getinfo();Human h3(h2); // = h2; // 定义h3,利用h3.Human(h2)-->触发拷贝构造函数h3.getinfo();Human h4; // 定义h4,利用h4.Human()-->h4维护的内容为(无名,0)cout << "h4被赋值前---";h4.getinfo();h4 = h3; // h4.operator=(h3)-->触发拷贝赋值函数cout << "h4被赋值后---";h4.getinfo();return 0;
}

5.2  拷贝赋值过程

        

6  初始化表

6.1  理论

        初始化表只能在构造函数中使用。

        通过在类的构造函数中使用初始化表，可以通知编译器该类的成员变量如何被初始化。

        类中的基本类型成员变量，最好在初始化表中显示指明如何初始化，否则初值不确定。

        类中的类类型成员变量，最好在初始化表中显示指明如何初始化，否则将调用相应类型的无参构造函数（维护一个空串""，即\0）。

// initlist.cpp
// 初始化表 -- 只能在构造函数中使用(指导编译器如何给定义出来的成员变量做初始化)
#include <iostream>
using namespace std;class Human {
public:
//  如果类没有提供任何构造函数,编译器将提供一个无参的构造函数
/*  Human() {【int m_age;】定义m_age,初值为随机数【string m_name;】定义m_name,利用m_name.string()}*/Human( int age=0, const char* name="无名" ) : m_age(age),m_name(name) {//【int m_age=age;】定义m_age,初值为age//【string m_name(name);】定义m_name,利用m_name.string(name)cout << "Human类缺省构造函数被调用" << endl;}
//  如果类没有提供拷贝构造函数,编译器将提供一个默认的拷贝构造函数
/*  Human( const Human& that ) { 【int m_age=that.m_age;】定义m_age,初值为that.m_age【string m_name(that.m_name);】定义m_name,利用m_name.string(that.m_name)-->//                     string类拷贝构造函数}*/Human( const Human& that ) : m_age(that.m_age), m_name(that.m_name) { //【int m_age=that.m_age;】定义m_age,初值为that.m_age//【string m_name(that.m_name);】定义m_name,利用m_name.string(that.m_name)cout << "Human类拷贝构造函数被调用" << endl;}
//  如果类没有提供拷贝赋值函数,编译器将提供一个默认的拷贝赋值函数
/*  Human& operator=( const Human& that ) {this->m_age = that.m_age;this->m_name = that.m_name; // this->m_name.operator=(that.m_name)-->//                  string类的拷贝赋值函数return *this;}*/Human& operator=( const Human& that ) {// 编译器不会再拷贝赋值函数中塞任何操作cout << "Human类的拷贝赋值函数被调用" << endl;this->m_age = that.m_age;this->m_name = that.m_name; // this->m_name.operator=(that.m_name)-->//                  string类的拷贝赋值函数return *this;}void getinfo( ) {cout << "姓名: " << m_name << ", 年龄: " << m_age << endl;}
private:int m_age; // 基本类型的成员变量string m_name; // 类类型的成员变量
};// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {Human h; // 定义h,利用h.Human()-->h维护的内容为(无名,0)h.getinfo( );Human h2(22,"张飞"); // 定义h2,利用h2.Human(22,"张飞")-->h2维护的内容为(张飞,22)h2.getinfo();Human h3(h2); // = h2; // 定义h3,利用h3.Human(h2)-->触发拷贝构造函数h3.getinfo();Human h4; // 定义h4,利用h4.Human()-->h4维护的内容为(无名,0)cout << "h4被赋值前---";h4.getinfo();h4 = h3; // h4.operator=(h3)-->触发拷贝赋值函数cout << "h4被赋值后---";h4.getinfo();return 0;
}

6.2  初始化表 过程图 

 

6.3  必须在初始化表中指明的情境

        类的常量型成员变量和引用型成员变量，必须在初始化表中显示初始化。

// hastoinit.cpp 必须使用初始化表的情况
#include <iostream>
#include <cstring>
using namespace std;class Human {
public:Human( int age=0, const char* name="无名", float score=0.0 ): m_age(age),m_name(name),m_score(score),m_len(strlen(name)) {//【int m_len=strlen(name);】//【int m_age=age;】定义m_age,初值为age//【string m_name(name);】定义m_name,利用m_name.string(name)//【const float m_score=score;】cout << "Human类缺省构造函数被调用" << endl;}Human( const Human& that ) :m_age(that.m_age),m_name(that.m_name),m_score(that.m_score),m_len(that.m_len){//【int m_len = that.m_len;】//【int m_age=that.m_age;】定义m_age,初值为that.m_age//【string m_name(that.m_name);】定义m_name,利用m_name.string(that.m_name)//【const float m_score=that.m_score;】cout << "Human类拷贝构造函数被调用" << endl;}void getinfo( ) {cout << "姓名: " << m_name << ", 年龄: " << m_age << ", 成绩:" << m_score<< ", 名字长度:" << m_len << endl;}
private:int m_len; // 保存名字字符串的长度int m_age;string m_name; // 保存名字字符串const float m_score; // 常量型的成员变量
//    int m_len; // 保存名字字符串的长度
};// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {Human h2(22,"张飞",88.5); // 触发缺省构造函数h2.getinfo();Human h3(h2); // 触发拷贝构造函数h3.getinfo();return 0;
}

6.4  初始化顺序

        类的成员变量按其在类中的声明顺序依次被初始化，而与其在初始化表中的顺序无关。

        为了 避开 顾及声明顺序，在初始化表中定义每个成员变量时，尽量不要牵扯其他成员变量，可以考虑用形参代替其他成员变量。。

// twodimensional.cpp 设计一个二维坐标系的 类
#include <iostream>
using namespace std;class TwoDimensional {
public:TwoDimensional( int x=0, int y=0 ) : m_x(x), m_y(y) {//【int m_x=x;】定义m_x初值为x//【int m_y=y;】 定义m_y初值为y}TwoDimensional( const TwoDimensional& that ) : m_x(that.m_x), m_y(that.m_y) {//【int m_x=that.m_x;】//【int m_y=that.m_y;】}TwoDimensional& operator=( const TwoDimensional& that ) {m_x = that.m_x;m_y = that.m_y;}void getinfo( /* TwoDimensional* this */ ) { // 非常函数cout << "横坐标: " << m_x << ", 纵坐标: " << m_y << endl;}
private:int m_x; // 横坐标int m_y; // 纵坐标
};int main( void ) {TwoDimensional a(100,300); // 定义a,利用a.TwoDimensional(100,300)a.getinfo( );TwoDimensional b(a); // = a;  --> 触发拷贝构造函数b.getinfo( );TwoDimensional c;c.getinfo( );c = b; // --> 拷贝赋值函数c.getinfo( );return 0;
}

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

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

相关文章

mysql sumif条件求和_sumif与sumifs条件求和函数详解，小白到大神的必经之路

mysql sumif条件求和_sumif与sumifs条件求和函数详解，小白到大神的必经之路

在日常工作中我们经常需要根据某些条件进行求和&#xff0c;今天就给大家介绍下&#xff0c;Excel中的条件求和函数sumif和sumifsSumif函数第一个参数&#xff1a;Range&#xff1a;条件区域&#xff0c;用于条件判断的单元格区域。第二个参数&#xff1a;Criteria&#xff1a;…
阅读更多...
第二类斯特林数总结

第二类斯特林数总结

第二类斯特林数总结 标签&#xff1a; 第二类斯特林数 最近做题的时候遇到了一些跟第二类斯特林数有关的东西&#xff0c;发现网上的资料不是很多&#xff0c;于是写一篇博客来总结一下。 第二类斯特林数 定义 第二类斯特林数\(S(n,m)\)表示的是把n个不同的小球放在m个相同的盒…
阅读更多...
python 装饰器 继承_Python设计模式之装饰器模式

python 装饰器 继承_Python设计模式之装饰器模式

装饰器模式无论何时我们想对一个对象添加额外的功能&#xff0c;都有下面这些不同的可选方法。如果合理&#xff0c;可以直接将功能添加到对象所属的类(例如&#xff0c;添加一个新的方法)使用组合使用继承注意&#xff0c;本文中的Decorator可以为装饰器或者修饰器。与继承相比…
阅读更多...
Thread.join(), CountDownLatch、CyclicBarrier和 Semaphore区别,联系及应用

Thread.join(), CountDownLatch、CyclicBarrier和 Semaphore区别,联系及应用

在java 1.5中&#xff0c;提供了一些非常有用的辅助类来帮助我们进行并发编程&#xff0c;比如CountDownLatch&#xff0c;CyclicBarrier和Semaphore&#xff0c;今天我们就来学习一下这三个辅助类的用法&#xff0c;　由于Thread.join()也和这三个类有类似用法&#xff0c;我也…
阅读更多...
string转short java_[Java基础]之 数据类型转换

string转short java_[Java基础]之 数据类型转换

数据类型转换存在的意义数据类型转换&#xff0c;在实际的应用开发中&#xff0c;常常会对不同类型的数字类型进行计算&#xff0c;所以就用到了数据转换。一方面&#xff0c;使用算术计算符对数字进行运算时&#xff0c;系统在适当的时候回进行自动转换&#xff1b;另一放方面…
阅读更多...
adb 静默安装_怎么实现Android APP静默安装

adb 静默安装_怎么实现Android APP静默安装

在 Android 中&#xff0c;如果要使用系统限制的权限(比如 android.permission.WRITE_SECURE_SETTINGS)&#xff0c;我们需要把程序安装到 /system/app/ 下。下面以 SecureSetting.apk 为例&#xff0c;演示这个操作。需要准备一台已经获得 Root 权限的手机。1、通过 USB 连接手…
阅读更多...
跟我一起读postgresql源码(十六)——Executor(查询执行模块之——control节点(下))

跟我一起读postgresql源码(十六)——Executor(查询执行模块之——control节点(下))

5.ModifyTable节点 先看一个ModifyTable节点的例子&#xff1a; postgres# explain update test_01 set id 5 where name xxx;QUERY PLAN ---------------------------------------------------------------Update on test_01 (cost0.00..23.75 rows6 width48)-> Seq Sc…
阅读更多...
java获取对象的子_java – 如何根据子对象字段获取父对象

java获取对象的子_java – 如何根据子对象字段获取父对象

家长班&#xff1a;public class Person {String firstName;String lastName;Long id;List phoneNumber new ArrayList<>();int age;public Person(String firstName, String lastName, int age, Long id, List phone) {super();this.firstName firstName;this.lastNam…
阅读更多...
vscode格式化关于符合eslint检测语法配置

vscode格式化关于符合eslint检测语法配置

.js文件插件&#xff1a;JavaScript Standard Style配置&#xff1a;解决ES6语法格式化 {"files.associations": {"*.js": "javascriptreact"} }.vue文件 配置&#xff1a; {"vetur.format.defaultFormatter.js": "vscode-typesc…
阅读更多...
二、配置数据源、SessionFactory、domain对象

二、配置数据源、SessionFactory、domain对象

1.在applicationContext.xml中配置数据源 <?xml version"1.0" encoding"utf-8"?> <beans xmlns"http://www.springframework.org/schema/beans"xmlns:xsi"http://www.w3.org/2001/XMLSchema-instance"xmlns:context"h…
阅读更多...
IDEA建立Spring MVC Hello World 详细入门教程

IDEA建立Spring MVC Hello World 详细入门教程

引子&#xff0c;其实从.NET转Java已经有几个月时间了&#xff0c;项目也做了不少&#xff0c;但是很多配置都是根据公司模板或者网上教程比忽略画瓢&#xff0c;对其中最简单的配置和设置并不完全理解&#xff0c;依旧是小白用户。最近项目不忙&#xff0c;重新梳理了一下Spri…
阅读更多...
java offsetdatetime_Java OffsetDateTime withHour()用法及代码示例

java offsetdatetime_Java OffsetDateTime withHour()用法及代码示例

Java中OffsetDateTime类的withHour()方法返回此OffsetDateTime的副本&#xff0c;其中一天中的小时数按照参数中的指定进行了更改。用法:public OffsetDateTime withHour(int hour)参数&#xff1a;此方法接受单个参数hour&#xff0c;该参数指定要在结果中设置的一天中的小时&…
阅读更多...
2048小游戏代码解析 C语言版

2048小游戏代码解析 C语言版

2048小游戏&#xff0c;也算是风靡一时的益智游戏。其背后实现的逻辑比较简单&#xff0c;代码量不算多&#xff0c;而且趣味性强&#xff0c;适合作为有语言基础的童鞋来加强编程训练。本篇分析2048小游戏的C语言实现代码。 前言 游戏截图&#xff1a; 游戏实现原理&#xff1…
阅读更多...
java中Decimaformat_Java中 DecimalFormat 用法详解

java中Decimaformat_Java中 DecimalFormat 用法详解

对Java中 DecimalFormat 的所有基础用法进行了一个汇总。DecimalFormat 类主要靠 # 和 0 两种占位符号来指定数字长度。0 表示如果位数不足则以 0 填充&#xff0c;# 表示只要有可能就把数字拉上这个位置。下面的例子包含了差不多所有的基本用法。import java.text.DecimalForm…
阅读更多...
java的栈堆的理解_理解堆与栈 - 一步一个脚印 - BlogJava

java的栈堆的理解_理解堆与栈 - 一步一个脚印 - BlogJava

一、引言&#xff1a;一直不太明白堆与栈到底是什么&#xff0c;是指一块内存区呢&#xff0c;还是指一种数据结构&#xff1f;编写程序中总提到内存分配的栈与堆的区别&#xff0c;静态与动态分配等&#xff0c;总也弄不明白&#xff0c;隐约知道一点&#xff0c;但总分不清堆…
阅读更多...
【递归与递推】青蛙过河

【递归与递推】青蛙过河

题目描述 有一条河&#xff0c;左边一个石墩(A区)上有编号为1&#xff0c;2&#xff0c;3&#xff0c;4&#xff0c;…&#xff0c;n的n只青蛙&#xff0c;河中有k个荷叶(C区)&#xff0c;还有h个石墩(D区)&#xff0c;右边有一个石墩(B区)&#xff0c;如下图2—5所示。n只青蛙…
阅读更多...
人民币读法的java程序_Java浮点数转人民币读法

人民币读法的java程序_Java浮点数转人民币读法

packagetheTest;public classNumToRmb {private String[] hanArr{"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};private String[] unitArr{"仟",&quo…
阅读更多...
python arp欺骗

python arp欺骗

使用python构造一个arp欺骗脚本 import os import sys from scapy.all import * import optparse def main():usage"usage:[-i interface] [-t IP to attack] [-g Gateway IP]"parseroptparse.OptionParser(usage)parser.add_option(-i,destinterface,helpselect int…
阅读更多...
java 如何使用dylib,如何在应用程序中使用dylib文件？

java 如何使用dylib,如何在应用程序中使用dylib文件？

I have created lib.dylib dynamic library. I want to use that library in my application.What are the Build setting and build phase settings are required?Steps to use the library in objective-c.解决方案so there are 2 ways...1) if the Dyld is available at li…
阅读更多...
python中的基本数据结构

python中的基本数据结构

要点概论&#xff1a; 1.了解序列 2.掌握列表 3.掌握元组 4.掌握字符串 5.掌握字典 6.掌握json 1.序列 在python中&#xff0c;最基本的数据结构是序列。 python提供了列表&#xff0c;元组&#xff0c;字符串等序列类型&#xff0c;可以进行某些特定的操作&#xff0c;这些操作…
阅读更多...
最新文章

Copyright @ 2022~2023