2023/9/12 -- C++/QT

news2024/11/22 23:38:37

作业

实现一个图形类（Shape），包含受保护成员属性：周长、面积，

                公共成员函数：特殊成员函数书写

定义一个圆形类（Circle），继承自图形类，包含私有属性：半径

                公共成员函数：特殊成员函数、以及获取周长、获取面积函数

定义一个矩形类（Rect），继承自图形类，包含私有属性：长度、宽度

                公共成员函数：特殊成员函数、以及获取周长、获取面积函数

在主函数中，分别实例化圆形类对象以及矩形类对象，并测试相关的成员函数。

 03hmwk.h:

#ifndef __03HMWK_H__
#define __03HMWK_H__

#include <iostream>
#define PI 3.14
using namespace std;

class Shape{
protected:
    double circumference;
    double size;
public:
    //无参构造
    Shape();
    //有参构造
    Shape(double c,double s);
    //析构
    ~Shape();
    //拷贝构造
    Shape(const Shape &other);
    //移动构造
    Shape(Shape && other);
    //拷贝赋值
    Shape & operator=(const Shape &other);
    //移动赋值
    Shape & operator=(Shape && other);
};

class Circle:public Shape{
private:
    double radius;
public:
    //无参构造
    Circle();
    //有参构造
    Circle(double r);
    //析构
    ~Circle();
    //拷贝构造
    Circle(const Circle &other);
    //移动构造
    Circle(Circle && other);
    //拷贝赋值
    Circle & operator=(const Circle &other);
    //移动赋值
    Circle & operator=(Circle && other);
    //获取周长
    double get_C();
    //获取面积
    double get_S();
};

class Rectangle:public Shape{
private:
    double length;
    double width;
public:
    //无参构造
    Rectangle();
    //有参构造
    Rectangle(double l,double w);
    //析构
    ~Rectangle();
    //拷贝构造
    Rectangle(const Rectangle &other);
    //移动构造
    Rectangle(Rectangle && other);
    //拷贝赋值
    Rectangle & operator=(const Rectangle &other);
    //移动赋值
    Rectangle & operator=(Rectangle && other);
    //获取周长
    double get_C();
    //获取面积
    double get_S();
};

#endif // 03HMWK_H

03hmwk.cpp:

#include <03hmwk.h>
//无参构造
Shape::Shape():circumference(0),size(0){
    cout<<"Shape::无参构造"<<endl;
}
//有参构造
Shape::Shape(double c,double s):circumference(c),size(s){
    cout<<"Shape::有参构造"<<endl;
}
//析构
Shape::~Shape(){
    cout<<"Shape::析构"<<endl;
}
//拷贝构造
Shape::Shape(const Shape &other):circumference(other.circumference),size(other.size){
    cout<<"Shape::拷贝构造"<<endl;
}
//移动构造
Shape::Shape(Shape && other):circumference(other.circumference),size(other.size){
    cout<<"Shape::移动构造"<<endl;
}
//拷贝赋值
Shape & Shape::operator=(const Shape &other){
    circumference = other.circumference;
    size = other.size;
    cout<<"Shape::拷贝赋值"<<endl;
    return *this;
}
//移动赋值
Shape & Shape::operator=(Shape && other){
    circumference = other.circumference;
    size = other.size;
    cout<<"Shape::移动赋值"<<endl;
    return *this;
}



/**********************************圆*************************************************/



//无参构造
Circle::Circle():Shape(0,0),radius(0){
    cout<<"Circle::无参构造"<<endl;
}
//有参构造
Circle::Circle(double r):Shape(2*PI*r,PI*r*r),radius(r){
    cout<<"Circle::有参构造"<<endl;
}
//析构
Circle::~Circle(){
    cout<<"Circle::析构"<<endl;
}
//拷贝构造
Circle::Circle(const Circle &other):Shape(other.circumference,other.size),radius(other.radius){
    cout<<"Circle::拷贝构造"<<endl;
}
//移动构造
Circle::Circle(Circle && other):Shape(other.circumference,other.size),radius(other.radius){
    cout<<"Circle::移动构造"<<endl;
}
//拷贝赋值
Circle & Circle::operator=(const Circle &other){
    circumference = other.circumference;
    size = other.size;
    radius = other.radius;
    cout<<"Circle::拷贝赋值"<<endl;
    return *this;
}
//移动赋值
Circle & Circle::operator=(Circle && other){
    circumference = other.circumference;
    size = other.size;
    radius = other.radius;
    cout<<"Circle::移动赋值"<<endl;
    return *this;
}
//获取周长
double Circle::get_C(){
    return circumference;
}
//获取面积
double Circle::get_S(){
    return size;
}




/***********************************矩形************************************************/




//无参构造
Rectangle::Rectangle():Shape(0,0),length(0),width(0){
    cout<<"Rectangle::无参构造"<<endl;
}
//有参构造
Rectangle::Rectangle(double l,double w):Shape(2*(l+w),l*w),length(l),width(w){
    cout<<"Rectangle::有参构造"<<endl;
}
//析构
Rectangle::~Rectangle(){
    cout<<"Rectangle::析构"<<endl;
}
//拷贝构造
Rectangle::Rectangle(const Rectangle &other):Shape(other.circumference,other.size),length(other.length),width(other.width){
    cout<<"Rectangle::拷贝构造"<<endl;
}
//移动构造
Rectangle::Rectangle(Rectangle && other):Shape(other.circumference,other.size),length(other.length),width(other.width){
    cout<<"Rectangle::移动构造"<<endl;
}
//拷贝赋值
Rectangle & Rectangle::operator=(const Rectangle &other){
    circumference = other.circumference;
    size = other.size;
    length = other.length;
    width = other.width;
    cout<<"Rectangle::拷贝赋值"<<endl;
    return *this;
}
//移动赋值
Rectangle & Rectangle::operator=(Rectangle && other){
    circumference = other.circumference;
    size = other.size;
    length = other.length;
    width = other.width;
    cout<<"Rectangle::移动赋值"<<endl;
    return *this;
}
//获取周长
double Rectangle::get_C(){
    return circumference;
}
//获取面积
double Rectangle::get_S(){
    return size;
}

main.cpp:

#include <03hmwk.h>

int main()
{
    Circle c1(5);
    cout<<"c1.C = "<<c1.get_C()<<endl;
    cout<<"c1.S = "<<c1.get_S()<<endl;
    Rectangle r1(5,4);
    cout<<"r1.C = "<<r1.get_C()<<endl;
    cout<<"r1.S = "<<r1.get_S()<<endl;
    Circle c2 = c1;
    cout<<"c2.C = "<<c2.get_C()<<endl;
    cout<<"c2.S = "<<c2.get_S()<<endl;
    Rectangle r2 = r1;
    cout<<"r2.C = "<<r2.get_C()<<endl;
    cout<<"r2.S = "<<r2.get_S()<<endl;
    Circle c3;
    c3 = c2;
    cout<<"c3.C = "<<c3.get_C()<<endl;
    cout<<"c3.S = "<<c3.get_S()<<endl;
    Rectangle r3;
    r3 = r2;
    cout<<"r3.C = "<<r3.get_C()<<endl;
    cout<<"r3.S = "<<r3.get_S()<<endl;
    Circle c4 = move(c3);
    cout<<"c4.C = "<<c4.get_C()<<endl;
    cout<<"c4.S = "<<c4.get_S()<<endl;
    Rectangle r4 = move(r3);
    cout<<"r4.C = "<<r4.get_C()<<endl;
    cout<<"r4.S = "<<r4.get_S()<<endl;
    Circle c5;
    c5 = move(c4);
    cout<<"c5.C = "<<c5.get_C()<<endl;
    cout<<"c5.S = "<<c5.get_S()<<endl;
    Rectangle r5;
    r5 = move(r4);
    cout<<"r5.C = "<<r5.get_C()<<endl;
    cout<<"r5.S = "<<r5.get_S()<<endl;
    return 0;
}

 效果图：

 

一、静态成员（static）

程序员有时在实例化对象时，想让某个成员或某几个成员独立于类对象而存在，但是又属于类对象的属性，不占用类对象的空间，那么此时我们可以将这些成员设置成静态成员，相当于在类体内定义一个全局的成员。静态成员分为静态成员变量和静态成员函数。

1.1 静态成员变量

  1. 定义格式：在定义成员变量时，在前面加关键字static，那么该变量就是静态成员变量
  2. 静态成员变量一般声明成public权限，并且需要在类内声明，类外定义，定义时如果不初始化，默认为0,
  3. 静态成员变量，不依附于类对象而存在，不占用类对象的空间，在编译时，系统在静态区为其分配空间
  4. 静态成员变量也是每个类对象拥有的属性，一个对象对其更改，所有对象的该属性都会更改
  5. 使用方式：每个类对象都可以使用成员运算符进行调用，也可以通过类名加作用域限定符直接调用
  6. 静态成员变量，从功能上来说相当于全局变量，但是相比于全局变量更能体现类的封装性
#include <iostream>

using namespace std;
class Stu
{
private:
    int age;
public:
    static int score;            //在类内声明
    Stu() {}
};

//在类外定义一下静态成员变量
int Stu::score = 100;

int main()
{
    Stu::score = 50;                  //通过 类名直接访问类中的静态成员变量

    Stu s;
    cout<<"score = "<<s.score<<endl;

    cout<<"sizeof s = "<<sizeof (s)<<endl;       //4字节，静态成员变量不占用类对象的空间

    Stu s1;
    cout<<"score = "<<s1.score<<endl;      //100

    Stu s2;
    s2.score = 90;                                //一个对象的该值进行改变，所有对象的该值都跟着改变
    cout<<"score = "<<s.score<<endl;
    cout<<"score = "<<s1.score<<endl;

    return 0;
}

1.2 静态成员函数

  1. 定义格式：在定义成员函数前加关键static，那么该函数就是静态成员函数
  2. 静态成员函数相当于在类体中定义一个全局函数，但是，只能是该类对象或者该类进行调用
  3. 静态成员函数的调用：可以使用类对象通过成员运算符进行调用也可以使用类名直接进行调用
  4. 静态成员函数中，没有this指针
  5. 静态成员函数，不依赖于类对象而存在，所以也可以不实例化对象，直接使用类名进行调用
  6. 在静态成员函数中，只能使用静态成员变量不能使用非静态成员变量
#include <iostream>

using namespace std;
class Stu
{
private:
    int age;
public:
    static int score;            //在类内声明
    Stu() {}
    Stu(int a):age(a) {}

    //该函数是静态成员函数
    static void show()
    {
        //cout<<"age = "<<age<<endl;           //在静态成员函数中不能使用非静态成员变量
        cout<<"score = "<<score<<endl;        //可以使用静态成员变量
    }

    //静态成员函数和同名的非静态成员函数不构成重载关系，原因是作用域不同
//    void show()
//    {
//        cout<<"age = "<<age<<endl;           //在静态成员函数中不能使用非静态成员变量
//        cout<<"score = "<<score<<endl;        //可以使用静态成员变量
//    }
};

//在类外定义一下静态成员变量
int Stu::score = 100;

int main()
{
    Stu::score = 50;                  //通过 类名直接访问类中的静态成员变量

    Stu s;
    cout<<"score = "<<s.score<<endl;

    cout<<"sizeof s = "<<sizeof (s)<<endl;       //4字节，静态成员变量不占用类对象的空间

    Stu s1;
    cout<<"score = "<<s1.score<<endl;      //100


    Stu s2;
    s2.score = 90;                                //一个对象的该值进行改变，所有对象的该值都跟着改变
    cout<<"score = "<<s.score<<endl;
    cout<<"score = "<<s1.score<<endl;
    cout<<"********************************************************"<<endl;

    Stu s3(18);
    s3.show();            //通过类对象调用静态成员函数

    Stu::show();            //通过函数名直接调用静态成员函数

    return 0;
}

二、继承（inherit）

2.1 继承的概念

1> 所谓继承，就是在一个类的基础上去定义另一个新类的过程叫做继承

2> 作用：

  1. 继承能够提高代码的复用性
  2. 继承是实现多态的必要条件

2.2 继承格式

class  子类名:继承方式  父类名
{
    //子类拓展的成员
}
继承方式有三种：public、protected、private

子类：也叫派生类
父类：也叫基类

2.3 继承方式对类中成员的权限的影响

父类中                    public|protected|private|不能访问                public|protected|private|不能访问          public|protected|private|不能访问         
继承方式                            public                                            protected                                   private
子类中                    public|protected|不能访问|不能访问                protected|protected|不能访问|不能访问       private|private|不能访问|不能访问

总结：

  1. 所谓继承方式，其实就是父类中的成员的访问权限在子类中的最高权限
  2. 如果继承过程中没有加访问权限，默认是私有继承
  3. 常用的继承方式是public
  4. 在所有继承方式中，都不能在子类中访问父类的私有成员以及父类不能访问的成员

2.4 子类会继承父类中的所有成员

1> 子类会继承父类中的所有成员，包括私有成员，只是私有成员不能访问而已

2> 父类和子类是不同的类

3> 为了对子类从父类中继承下来成员进行初始化工作，需要在子类的构造函数初始化列表中显性调用父类的有参构造完成，否则系统会自动调用父类的无参构造，此时，如果父类没有无参构造，则系统报错

4> 在这个过程中，虽然调用了父类的构造函数，但是，并没有实例化一个父类对象

#include <iostream>

using namespace std;

class Person
{
public:
    string name;
protected:
    int value;
private:
    double money;            //私房钱

public:
    Person() {cout<<"Person::无参构造"<<endl;}
    Person(string n, int v, double m):name(n),value(v),money(m) {cout<<"Person::有参构造"<<endl;}

    void show()
    {
        cout<<"Person::name = "<<name<<endl;          //自己类中的公有成员，自己类内可以访问
        cout<<"Person::value = "<<value<<endl;       //自己类中的受保护成员，自己类内可以访问
        cout<<"Person::money = "<<money<<endl;           //自己类中的私有成员，自己类内可以访问
    }
};

//定义一个员工类，继承自人类
class Worker:public Person           //公有继承
/*class Worker:protected Person*/            //受保护继承
//class Worker:private Person
{
private:
    double salary;           //工资

public:
    Worker() {cout<<"Worker::无参构造"<<endl;}
    //需要在子类的构造函数中显性调用父类的有参构造完成对子类从父类中继承下来的成员的初始化
    Worker(string n, int v, double m, double s):Person(n,v,m), salary(s)
    {
//        name = n;
//        value = v;
//        money = m;
        cout<<"Worker::有参构造"<<endl;
    }

    void display()
    {
        cout<<"Worker::name = "<<name<<endl;       //继承下来的公有成员，子类中还是公有成员，子类内可以访问
        cout<<"Worker::value = "<<value<<endl;      //继承下来的受保护成员，子类中还是受保护成员，子类内可以访问
        //cout<<"Worker::money = "<<money<<endl;     //继承下来的父类私有成员，子类中不可访问
        cout<<"Worker::salary = "<<salary<<endl;      //自己的私有成员，类内可以访问
    }
};

int main()
{
    //cout << sizeof(Worker) << endl;
   // Worker w;
 //   cout<<"w.name = "<<w.name<<endl;         //继承下来的公有成员，子类中也是公有的，类外可以被访问
 //   cout<<"w.value = "<<w.value<<endl;      //继承下来的受保护成员，子类中也是受保护的，子类外不能被访问
//    cout<<"w.money = "<<w.money<<endl;      //继承下来的私有成员，子类中不能被访问，类外不能被访问
//    cout<<"w.salary = "<<w.salary<<endl;    //子类的私有成员，子类外无法访问

    Worker w1("zhangpp", 520, 1, 100);
    w1.display();
    w1.show();

    return 0;
}

2.5 类的关系模型

1> has - a模型

包含关系，一个类中包含另一个类的成员对象

2> use - a模型

友元关系，将某个类设置成友元，那么另一个类就可以使用自己的所有权限下的成员

3> is - a模型

继承关系，并且，is-a模型是特殊的has-a模型

2.6 类的继承步骤

1> 全盘吸收父类

2> 改造父类：继承方式、通过using关键字改变

3> 拓展新成员

#include <iostream>

using namespace std;

class Person
{
public:
    string name;    
protected:
    int salary;    
private:
    int money;    
public:
    Person() {}
};

//定义学生类继承自Person
class Stu:public Person
{
protected:
    using Person::name;        //将继承的name的权限更改成受保护权限
    
public:
    using Person::salary;         //将继承的salary权限更改成公共权限
    
    //using Person::money;          //父类的私有成员不能进行改造
    
    double score;              //拓展新成员
    
public:
    Stu() {}
    
    
};

int main()
{
    Stu s;
    
    //s.name = "hello";
    //s.salary = 1000;
    
    return 0;
}

 

 

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

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

相关文章

数据结构题型3--按序查找

数据结构题型3--按序查找

#include <iostream> //引入头文件 using namespace std;typedef int Elemtype;#define Maxsize 100 #define ERROR 0 #define OK 1typedef struct LNode {Elemtype data;//数据域struct LNode* next;//指针域 }LNode, * LinkList;bool InitList(LinkList& L) …
阅读更多...
OpenCV（三十九）：积分图像

OpenCV（三十九）：积分图像

1.积分图像介绍 积分图像中的每个像素表示了原始图像中对应位置及其左上方矩形区域内像素值的总和。如图&#xff0c;p0表示原始图像蓝色区域内像素值的总和。 倾斜求和&#xff08;Skewed Sum&#xff09;是积分图像的一种扩展形式&#xff0c;用于计算图像区域内的像素和&…
阅读更多...
小白带你学习linux自动化运维ansible

小白带你学习linux自动化运维ansible

目录 一、为什么要用自动化运维软件 二、自动化运维要注意的方面 1、管理机与被管理机之间的连接方式 2、服务器分组(主机清单) 3,、自动化运维的管理分类 三、常见的开源自动化运维软件 1、puppet 2、saltstack 3、ansible 四、自动化运维软件一般安装在哪 五、ans…
阅读更多...
【栈与队列面试题】有效的括号（动图演示）

【栈与队列面试题】有效的括号（动图演示）

leetcode20.括号匹配问题 前言&#xff1a; &#x1f4a5;&#x1f388;个人主页:​​​​​​Dream_Chaser&#xff5e; &#x1f388;&#x1f4a5; ✨✨刷题专栏:http://t.csdn.cn/UlvTc ⛳⛳本篇内容:力扣上栈与队列的面试OJ题目 目录 leetcode20.括号匹配问题 1.问题描…
阅读更多...
2023-9-12 多重背包问题(二)

2023-9-12 多重背包问题(二)

题目链接&#xff1a;多重背包问题 II #include <iostream> #include <algorithm>using namespace std;const int N 12010, M 2010;int n, m; int v[N], w[N]; int f[M];int main() {cin >> n >> m;// 最后一共转换成多少个物品int cnt 0;for(int i…
阅读更多...
Rust通用编程概念(3)

Rust通用编程概念(3)

Rust通用编程概念 1.变量和可变性1.执行cargo run2.变量3.变量的可变性4.常量5.遮蔽5.1遮蔽与mut区别1.遮蔽2.mut 2.数据类型1.标量类型1.1整数类型1.2浮点数类型1.3数字运算1.4布尔类型1.5字符类型 2.复合类型2.1元组类型2.2数组类型1.访问数组2.无效的数组元素访问 3.函数3.1…
阅读更多...
9月12日作业

9月12日作业

作业代码 #include <iostream>using namespace std;class Shape { protected:double cir;double area; public://无参构造Shape() {cout<<"无参构造"<<endl;}//有参构造Shape(double c, double a):cir(c), area(a){cout<<"有参构造&quo…
阅读更多...
Maven Helper mvn项目冲突如何解决

Maven Helper mvn项目冲突如何解决

一般用这款插件来查看maven的依赖树。 一、安装&#xff1a; File-->setting--->Plugins--->在搜索框中填写Maven Helper然后搜索&#xff0c;单击Install按钮进行安装&#xff0c;装完重启IDE。 二、使用 当Maven Helper 插件安装成功后&#xff0c;打开项目中的p…
阅读更多...
【算法基础】时间复杂度和空间复杂度

【算法基础】时间复杂度和空间复杂度

目录 1 算法的评价 2 算法复杂度 2.1 时间复杂度&#xff08;Time Complexity&#xff09; 2.1.1 如何计算时间复杂度&#xff1a; 2.1.2 常见的时间复杂度类别与示例 2.2 空间复杂度 2.2.1 如何计算空间复杂度 2.2.2 常见的空间复杂度与示例 3 时间复杂度和空间复杂度…
阅读更多...
docker 部署 node.js（express） 服务

docker 部署 node.js（express） 服务

1、在 express 项目根目录下新增 Dockerfile 文件&#xff0c;内容如下&#xff1a; 创建服务容器的方法&#xff0c;可以根据自己的情况选择&#xff1a; 1、以下示例为宿主机没有安装 node 环境的写法&#xff1b; 2、先在本地构建包含 node 和 express 的基础镜像&#xff0…
阅读更多...
【C++】day5学习成果：继承和六个特殊成员函数的代码应用、静态成员 继承 类的关系模型 类的继承步骤的思维导图。

【C++】day5学习成果：继承和六个特殊成员函数的代码应用、静态成员 继承 类的关系模型 类的继承步骤的思维导图。

1.代码题&#xff1a;实现一个图形类&#xff08;Shape&#xff09;&#xff0c;包含受保护成员属性&#xff1a;周长、面积&#xff0c; 公共成员函数&#xff1a;特殊成员函数书写 定义一个圆形类&#xff08;Circle&#xff09;&#xff0c;继承自图形类&#xff0c;包含私有…
阅读更多...
STC15/8单片机特有的PWM寄存器和普通定时器实现PWM输出

STC15/8单片机特有的PWM寄存器和普通定时器实现PWM输出

STC15/8单片机特有的PWM寄存器和普通定时器实现PWM输出 🌿主要针对STC15W4型号特有的6通道15位专门的高精度PWM。 🌿STC8系列 ✨STC15W4K32S4系列单片机具有6通道15位专门的高精度PWM(带死区控制)和2通道CCP(利用它的高速脉冲输出功能可实现11~16位PWM)；（STC15F/L2K60S2系…
阅读更多...
JAVA8接口使用问题

JAVA8接口使用问题

JAVA8接口使用问题 文章目录 JAVA8接口使用问题1、默认方法冲突问题&#xff08;1&#xff09;亲爹优先原则&#xff08;2&#xff09;左右为难 2、常量冲突问题 1、默认方法冲突问题 &#xff08;1&#xff09;亲爹优先原则 当一个类&#xff0c;既继承一个父类&#xff0c;…
阅读更多...
助力智能化公路养护，基于YOLOv5s集成SPD-BIFPN-SE开发构建公路开裂检测识别系统

助力智能化公路养护，基于YOLOv5s集成SPD-BIFPN-SE开发构建公路开裂检测识别系统

在前文中我们尝试构建了在隧道、涵洞尝尽下的自动智能化养护巡查相关的模型&#xff0c;进行了实地测试评估&#xff0c;感兴趣的话可以自行移步阅读即可&#xff1a; 《基于轻量级YOLOv5s开发构建隧道基建裂痕、脱落等缺陷问题检测系统》 本文的想法是相近的&#xff0c;核心…
阅读更多...
Linkerd2初探

Linkerd2初探

Linkerd2初探 部署环境Linkerd简介安装Linkerd客户端在k8s上安装Linkerd控制平面&#xff08;服务端&#xff09;实验&#xff1a;数据平面代理注入demo应用安装viz插件&#xff08;可视化面板&#xff09;部署grafana 其他 部署环境 k8s环境: KIND 模拟kubernetes 1.21.1 kub…
阅读更多...
页面设计都有哪些好用的工具推荐？

页面设计都有哪些好用的工具推荐？

对于设计师来说&#xff0c;方便的页面设计工具和稳定的页面设计灵感也同样重要。 在今天的信息爆炸中&#xff0c;很容易找到页面设计工具&#xff0c;网上搜索有很多建议&#xff0c;但找到合适的页面设计工具并不那么简单。 本文推荐不容错过的9款页面设计工具 即时设计 …
阅读更多...
【DevOps核心理念基础】3. 敏捷开发最佳实践

【DevOps核心理念基础】3. 敏捷开发最佳实践

一、敏捷开发最佳实践 1.1 项目管理 1.2 需求管理 1.3 技术架构 1.4 技术开发 1.5 测试 二、敏捷开发最佳实践 2.1 敏捷开发的执行细节 三、全面的DevOps工具链 四、版本控制和协作开发工具 4.1 集中式版本控制工具 4.2 分布式版本控制工具 一、敏捷开发最佳实践 …
阅读更多...
mysql的一些知识点或者说踩过的坑和想记住的内容

mysql的一些知识点或者说踩过的坑和想记住的内容

快速上传数据 这个应该是比inset into values更快的插入数据的办法了。 不过要求挺苛刻的&#xff0c;数据要整理成和表格一致&#xff0c;也就是说每条数据都是完整的一条&#xff0c;而不是一部分。 下面的示例我以***为分割符划分字段&#xff0c;以 \n来分割每条数据。 LO…
阅读更多...
【atoi函数的功能介绍及使用与模拟实现——超详细版本】

【atoi函数的功能介绍及使用与模拟实现——超详细版本】

atoi函数的功能介绍及使用与模拟实现——超详细版本 1.cplusplus网站介绍&#x1f4bb; 1.1atoi函数的功能介绍&#x1f4bb; 它的功能&#xff1a; 解析将其内容解释为整数的 C 字符串&#xff0c;该整数作为 类型的值返回。 该函数首先根据需要丢弃尽可能多的空格字符&…
阅读更多...
java复习-eclipse开发工具使用

java复习-eclipse开发工具使用

开发工具使用 项目文件结构 建立完成的项目目录中会自动创建有两个子目录&#xff1a; src&#xff1a;保存所有的 *.java 源文件bin&#xff1a;保存所有编译后的 *.class 程序文件&#xff0c;这些文件会自动进行编译处理 保存文件后&#xff0c;会自动进行编译。 快捷键…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023