static相关的一些编程心得

最新推荐文章于 2022-03-14 23:24:25 发布
最新推荐文章于 2022-03-14 23:24:25 发布
阅读量152 收藏
点赞数
分类专栏： C 计算机基础 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nyist_yangguang/article/details/113064269
版权
c++ 同时被 3 个专栏收录
61 篇文章 1 订阅
订阅专栏
计算机基础
54 篇文章 2 订阅
订阅专栏
C
18 篇文章 0 订阅
订阅专栏

https://blog.csdn.net/guotianqing/article/details/79828100   static的一些介绍

1. 使用static声明变量  ：避免栈中数组越界导致不可预知错误

#include<stdio.h>
#include<string.h>
#include<iostream>
using namespace std;
int main()
{
    static int queue[100];
    static int a[10];
    static int b[10];
    memset(queue,0,sizeof(queue));
    int n,m;
    scanf("%d",&n);
    for(int i=0;i<n;i++)
        scanf("%d",&a[i]);
    scanf("%d",&m);
    for(int i=0;i<m;i++)
        scanf("%d",&b[i]);
//    int a[10]={2,4,1,2,5,6};
//    int b[10]={3,1,3,5,6,4};
    int a_left=0,a_right=n;
    int b_left=0,b_right=m;
    int temp_left=0,temp_right=0;
    while(a_left!=a_right && b_left!=b_right)
    {
        cout<<"*** "<<temp_left<<" ***  "<<temp_right<<endl;
        cout<<"queue: ";
        for(int i=temp_left;i<temp_right;i++)
            cout<<queue[i]<<" ";
        cout<<endl;
        for(int i=a_left;i<a_right;i++)
            cout<<a[i]<<" ";
        cout<<endl;
        for(int i=b_left;i<b_right;i++)
            cout<<b[i]<<" ";
        cout<<endl;

        queue[temp_right++]=a[a_left++];
         for(int i=b_left;i<b_right;i++)
            cout<<b[i]<<" ";
        cout<<endl;
        int temp=temp_left;
        while(temp<temp_right-1)
        {
            if(queue[temp_right-1]==queue[temp++] && temp_right!=1)
            {
//                for(int i=temp-1;i<=temp_right-1;i++)
               for(int i=temp_right-1;i>=temp-1;i--)
                {
                    a[a_right++]=queue[i];
                }
                temp_right=temp-1;
                break;
            }
        }

         for(int i=b_left;i<b_right;i++)
            cout<<b[i]<<" ";
        cout<<endl;

        queue[temp_right++]=b[b_left++];
        temp=temp_left;
        while(temp<temp_right-1)
        {
            if(b[b_left-1]==queue[temp++]&& temp_right!=1)
            {
//                for(int i=temp-1;i<=temp_right-1;i++)
                for(int i=temp_right-1;i>=temp-1;i--)
                {
                    b[b_right++]=queue[i];
                }
                temp_right=temp-1;
                break;
            }
        }


        for(int i=b_left;i<b_right;i++)
            cout<<b[i]<<" ";
        cout<<endl;


    }
    cout<<"queue: ";
        for(int i=temp_left;i<temp_right;i++)
            cout<<queue[i]<<" ";
        cout<<endl;
        for(int i=a_left;i<a_right;i++)
            cout<<a[i]<<" ";
        cout<<endl;
        for(int i=b_left;i<b_right;i++)
            cout<<b[i]<<" ";
        cout<<endl;
        cout<<a_left<<"  "<<a_right<<endl;

        cout<<endl;
    if(a_left==a_right)
    {
        printf("b win\n");
    }
    else
        printf("a win\n");
}

6
2 4 1 2 5 6
6
3 1 3 5 6 4
*** 0 ***  0
queue:
2 4 1 2 5 6
3 1 3 5 6 4
3 1 3 5 6 4
3 1 3 5 6 4
1 3 5 6 4
*** 0 ***  2
queue: 2 3
4 1 2 5 6
1 3 5 6 4
1 3 5 6 4
1 3 5 6 4
3 5 6 4
*** 0 ***  4
queue: 2 3 4 1
1 2 5 6
3 5 6 4
3 5 6 4
3 5 6 4
5 6 4 3 4 3
*** 0 ***  1
queue: 2
2 5 6 1 1
5 6 4 3 4 3
5 6 4 3 4 3
5 6 4 3 4 3
6 4 3 4 3
*** 0 ***  1
queue: 5
5 6 1 1 2 2
6 4 3 4 3
6 4 3 4 3
6 4 3 4 3
4 3 4 3
*** 0 ***  1
queue: 6
6 1 1 2 2 5 5
4 3 4 3
4 3 4 3
4 3 4 3
3 4 3
*** 0 ***  1
queue: 4
1 1 2 2 5 5 6 6
3 4 3
3 4 3
3 4 3
4 3
*** 0 ***  3
queue: 4 1 3
1 2 2 5 5 6 6
4 3
4 3
4 3
3 4 4
*** 0 ***  0
queue:
2 2 5 5 6 6 1 3 1
3 4 4
3 4 4
3 4 4
4 4
*** 0 ***  2
queue: 2 3
2 5 5 6 6 1 3 1
4 4
4 4
4 4
4
*** 0 ***  1
queue: 4
5 5 6 6 1 3 1 2 3 2
4
4
4
4 5 4
*** 0 ***  0
queue:
5 6 6 1 3 1 2 3 2
4 5 4
4 5 4
4 5 4
5 4
*** 0 ***  2
queue: 5 4
6 6 1 3 1 2 3 2
5 4
5 4
5 4
4 5 6 4 5
*** 0 ***  0
queue:
6 1 3 1 2 3 2
4 5 6 4 5
4 5 6 4 5
4 5 6 4 5
5 6 4 5
*** 0 ***  2
queue: 6 4
1 3 1 2 3 2
5 6 4 5
5 6 4 5
5 6 4 5
6 4 5
*** 0 ***  4
queue: 6 4 1 5
3 1 2 3 2
6 4 5
6 4 5
6 4 5
4 5 6 3 5 1 4 6
*** 0 ***  0
queue:
1 2 3 2
4 5 6 3 5 1 4 6
4 5 6 3 5 1 4 6
4 5 6 3 5 1 4 6
5 6 3 5 1 4 6
*** 0 ***  2
queue: 1 4
2 3 2
5 6 3 5 1 4 6
5 6 3 5 1 4 6
5 6 3 5 1 4 6
6 3 5 1 4 6
*** 0 ***  4
queue: 1 4 2 5
3 2
6 3 5 1 4 6
6 3 5 1 4 6
6 3 5 1 4 6
3 5 1 4 6
*** 0 ***  6
queue: 1 4 2 5 3 6
2
3 5 1 4 6
3 5 1 4 6
3 5 1 4 6
5 1 4 6
*** 0 ***  3
queue: 1 4 3
2 6 3 5 2
5 1 4 6
5 1 4 6
5 1 4 6
1 4 6
*** 0 ***  5
queue: 1 4 3 2 5
6 3 5 2
1 4 6
1 4 6
1 4 6
4 6 1 6 5 2 3 4 1
*** 0 ***  0
queue:
3 5 2
4 6 1 6 5 2 3 4 1
4 6 1 6 5 2 3 4 1
4 6 1 6 5 2 3 4 1
6 1 6 5 2 3 4 1
*** 0 ***  2
queue: 3 4
5 2
6 1 6 5 2 3 4 1
6 1 6 5 2 3 4 1
6 1 6 5 2 3 4 1
1 6 5 2 3 4 1
*** 0 ***  4
queue: 3 4 5 6
2
1 6 5 2 3 4 1
1 6 5 2 3 4 1
1 6 5 2 3 4 1
6 5 2 3 4 1
queue: 3 4 5 6 2 1

6 5 2 3 4 1
25  25

b win

Process returned 0 (0x0)   execution time : 10.840 s
Press any key to continue.

2. 未使用static数组越界导致数据被篡改

#include<stdio.h>
#include<string.h>
#include<iostream>
using namespace std;
int main()
{
    int queue[100];
    int a[10];
    int b[10];
    memset(queue,0,sizeof(queue));
    int n,m;
    scanf("%d",&n);
    for(int i=0;i<n;i++)
        scanf("%d",&a[i]);
    scanf("%d",&m);
    for(int i=0;i<m;i++)
        scanf("%d",&b[i]);
//    int a[10]={2,4,1,2,5,6};
//    int b[10]={3,1,3,5,6,4};
    int a_left=0,a_right=n;
    int b_left=0,b_right=m;
    int temp_left=0,temp_right=0;
    while(a_left!=a_right && b_left!=b_right)
    {
        cout<<"*** "<<temp_left<<" ***  "<<temp_right<<endl;
        cout<<"queue: ";
        for(int i=temp_left;i<temp_right;i++)
            cout<<queue[i]<<" ";
        cout<<endl;
        for(int i=a_left;i<a_right;i++)
            cout<<a[i]<<" ";
        cout<<endl;
        for(int i=b_left;i<b_right;i++)
            cout<<b[i]<<" ";
        cout<<endl;

        queue[temp_right++]=a[a_left++];
         for(int i=b_left;i<b_right;i++)
            cout<<b[i]<<" ";
        cout<<endl;
        int temp=temp_left;
        while(temp<temp_right-1)
        {
            if(queue[temp_right-1]==queue[temp++] && temp_right!=1)
            {
//                for(int i=temp-1;i<=temp_right-1;i++)
               for(int i=temp_right-1;i>=temp-1;i--)
                {
                    a[a_right++]=queue[i];
                }
                temp_right=temp-1;
                break;
            }
        }

         for(int i=b_left;i<b_right;i++)
            cout<<b[i]<<" ";
        cout<<endl;

        queue[temp_right++]=b[b_left++];
        temp=temp_left;
        while(temp<temp_right-1)
        {
            if(b[b_left-1]==queue[temp++]&& temp_right!=1)
            {
//                for(int i=temp-1;i<=temp_right-1;i++)
                for(int i=temp_right-1;i>=temp-1;i--)
                {
                    b[b_right++]=queue[i];
                }
                temp_right=temp-1;
                break;
            }
        }


        for(int i=b_left;i<b_right;i++)
            cout<<b[i]<<" ";
        cout<<endl;


    }
    cout<<"queue: ";
        for(int i=temp_left;i<temp_right;i++)
            cout<<queue[i]<<" ";
        cout<<endl;
        for(int i=a_left;i<a_right;i++)
            cout<<a[i]<<" ";
        cout<<endl;
        for(int i=b_left;i<b_right;i++)
            cout<<b[i]<<" ";
        cout<<endl;
        cout<<a_left<<"  "<<a_right<<endl;

        cout<<endl;
    if(a_left==a_right)
    {
        printf("b win\n");
    }
    else
        printf("a win\n");
}


6
2 4 1 2 5 6
6
3 1 3 5 6 4
*** 0 ***  0
queue:
2 4 1 2 5 6
3 1 3 5 6 4
3 1 3 5 6 4
3 1 3 5 6 4
1 3 5 6 4
*** 0 ***  2
queue: 2 3
4 1 2 5 6
1 3 5 6 4
1 3 5 6 4
1 3 5 6 4
3 5 6 4
*** 0 ***  4
queue: 2 3 4 1
1 2 5 6
3 5 6 4
3 5 6 4
3 5 6 4
5 6 4 3 4 3
*** 0 ***  1
queue: 2
2 5 6 1 1
5 6 4 3 4 3
5 6 4 3 4 3
5 6 4 3 4 3
6 4 3 4 3
*** 0 ***  1
queue: 5
5 6 1 1 2 2
6 4 3 4 3
6 4 3 4 3
6 4 3 4 3
4 3 4 3
*** 0 ***  1
queue: 6
6 1 1 2 2 5 5
4 3 4 3
4 3 4 3
4 3 4 3
3 4 3
*** 0 ***  1
queue: 4
1 1 2 2 5 5 6 6
3 4 3
3 4 3
3 4 3
4 3
*** 0 ***  3
queue: 4 1 3
1 2 2 5 5 6 6
4 3
4 3
4 3
3 4 4
*** 0 ***  0
queue:
2 2 5 5 6 6 1 3 1
3 4 4
3 4 2
3 4 2
4 2
*** 0 ***  2
queue: 2 3
2 5 5 6 6 1 3 1
4 2
4 2
2 2
2
*** 0 ***  1
queue: 2
5 5 6 6 1 3 1 2 3 2
2
2
2
2 2 2
*** 0 ***  0
queue:
5 6 6 1 3 1 2 3 2
2 2 2
2 2 2
2 2 2
2 2
*** 0 ***  2
queue: 5 2
6 6 1 3 1 2 3 2
2 2
6 2
6 2
6 6 6
*** 0 ***  2
queue: 5 2
6 1 3 1 2 3 2
6 6 6
6 6 6
6 6 6
6 6 6 6
*** 0 ***  2
queue: 5 2
1 3 1 2 3 2
6 6 6 6
6 6 6 6
6 6 6 6
6 6 6
*** 0 ***  4
queue: 5 2 1 6
3 1 2 3 2
6 6 6
6 6 6
6 6 6
6 6 6 3 6
*** 0 ***  3
queue: 5 2 1
1 2 3 2
6 6 6 3 6
6 6 6 3 6
6 6 6 3 6
6 6 3 6
*** 0 ***  3
queue: 1 1 6
2 3 2 1 1
6 6 3 6
6 6 3 6
6 6 3 6
6 3 6 6 2 6
*** 0 ***  2
queue: 1 1
3 2 1 1
6 3 6 6 2 6
6 3 6 6 2 6
6 3 6 6 2 6
3 6 6 2 6
*** 0 ***  4
queue: 1 1 3 6
2 1 1
3 6 6 2 6
3 6 6 2 6
3 6 6 2 6
6 6 2 6 3 2 6 3
*** 0 ***  2
queue: 1 1
1 1
6 6 2 6 3 2 6 3
6 6 2 6 3 2 6 3
6 6 2 6 3 2 6 3
6 2 6 3 2 6 3
*** 0 ***  1
queue: 6
1 1 1 1
6 2 6 3 2 6 3
6 2 6 3 2 6 3
6 2 6 3 2 6 3
2 6 3 2 6 3 6 1 6
*** 0 ***  0
queue:
6 1 1
2 6 3 2 6 3 6 1 6
2 6 3 2 6 3 6 1 6
2 6 3 2 6 3 6 1 6
6 3 2 6 3 6 1 6
*** 0 ***  2
queue: 6 2
1 1
6 3 2 6 3 6 1 6
6 3 2 6 3 6 1 6
6 3 2 6 3 6 1 6
3 2 6 3 6 1 6 6 1 2 6
*** 0 ***  0
queue:
1
3 2 6 3 6 1 6 6 1 2 6
3 2 6 3 6 1 6 6 1 2 6
3 2 6 3 6 1 6 6 1 2 6
2 6 3 6 1 6 6 1 2 6
queue: 1 3

2 6 3 6 1 6 6 1 2 6
25  25

b win

Process returned 0 (0x0)   execution time : 9.059 s
Press any key to continue.

3. 改变解决方案的思路，避免数组越界等混杂情况的发生，可以不使用static

#include<stdio.h>
#include<iostream>
#include<string.h>
using namespace std;
struct queue
{
    int data[1000];
    int head;
    int tail;
};
struct stack
{
    int data[10];
    int top;
};
int main()
{
    struct queue q1,q2;
    struct stack s;
    int book[10];
    q1.head=1,q1.tail=1;
    q2.head=1,q2.tail=1;
    s.top=0;
    memset(book,0,sizeof(book));
    for(int i=1; i<=6; i++)
    {
        scanf("%d",&q1.data[q1.tail++]);
    }
    for(int i=1; i<=6; i++)
    {
        scanf("%d",&q2.data[q2.tail++]);
    }
    int t;
    while(q1.head<q1.tail && q2.head<q2.tail)
    {
        for(int i=1;i<=s.top;i++)
            printf("%d ",s.data[i]);
        printf("\n");
        for(int i=q1.head;i<q1.tail;i++)
            printf("%d ",q1.data[i]);
        printf("\n");
        for(int i=q2.head;i<q2.tail;i++)
            printf("%d ",q2.data[i]);
        printf("\n\n");

        t=q1.data[q1.head];
        if(book[t]==0)
        {
            q1.head++;
            s.data[++s.top]=t;
            book[t]=1;
        }
        else
        {
            q1.head++;
            q1.data[q1.tail++]=t;
            while(s.data[s.top]!=t)
            {
                book[s.data[s.top]]=0;
                q1.data[q1.tail++]=s.data[s.top--];
            }
            book[s.data[s.top]]=0;
            q1.data[q1.tail++]=s.data[s.top--];
        }

        t=q2.data[q2.head];
        if(book[t]==0)
        {
            q2.head++;
            s.data[++s.top]=t;
            book[t]=1;
        }
        else
        {
            q2.head++;
            q2.data[q2.tail++]=t;
            while(s.data[s.top]!=t)
            {
                book[s.data[s.top]]=0;
                q2.data[q2.tail++]=s.data[s.top--];
            }
            book[s.data[s.top]]=0;
            q2.data[q2.tail++]=s.data[s.top--];
        }

    }
    cout<<q1.head<<" "<<q1.tail<<endl;
    cout<<q2.head<<" "<<q2.tail<<endl;
    if(q2.head==q2.tail)
    {
        printf("小哼 win\n");
        for(int i=q1.head; i<q1.tail; i++)
            cout<<q1.data[i]<<" ";
        cout<<endl;
        if(s.top>0)
        {
            for(int i=1; i<=s.top; i++)
            {
                cout<<s.data[i]<<" ";
            }
        }
        cout<<endl;

    }
    if(q1.head==q1.tail)
    {
        printf("小哈 win\n");
        for(int i=q2.head; i<q2.tail; i++)
            cout<<q2.data[i]<<" ";
        cout<<endl;
        if(s.top>0)
        {
            for(int i=1; i<=s.top; i++)
            {
                cout<<s.data[i]<<" ";
            }
        }
        cout<<endl;

    }
}


2 4 1 2 5 6
3 1 3 5 6 4

2 4 1 2 5 6
3 1 3 5 6 4

2 3
4 1 2 5 6
1 3 5 6 4

2 3 4 1
1 2 5 6
3 5 6 4

2
2 5 6 1 1
5 6 4 3 4 3

5
5 6 1 1 2 2
6 4 3 4 3

6
6 1 1 2 2 5 5
4 3 4 3

4
1 1 2 2 5 5 6 6
3 4 3

4 1 3
1 2 2 5 5 6 6
4 3


2 2 5 5 6 6 1 3 1
3 4 4

2 3
2 5 5 6 6 1 3 1
4 4

4
5 5 6 6 1 3 1 2 3 2
4


5 6 6 1 3 1 2 3 2
4 5 4

5 4
6 6 1 3 1 2 3 2
5 4


6 1 3 1 2 3 2
4 5 6 4 5

6 4
1 3 1 2 3 2
5 6 4 5

6 4 1 5
3 1 2 3 2
6 4 5


1 2 3 2
4 5 6 3 5 1 4 6

1 4
2 3 2
5 6 3 5 1 4 6

1 4 2 5
3 2
6 3 5 1 4 6

1 4 2 5 3 6
2
3 5 1 4 6

1 4 3
2 6 3 5 2
5 1 4 6

1 4 3 2 5
6 3 5 2
1 4 6


3 5 2
4 6 1 6 5 2 3 4 1

3 4
5 2
6 1 6 5 2 3 4 1

3 4 5 6
2
1 6 5 2 3 4 1

26 26
26 32
小哈 win
6 5 2 3 4 1
3 4 5 6 2 1

Process returned 0 (0x0)   execution time : 6.241 s
Press any key to continue.

 

程序猿的探索之路
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Linux多线程服务端编程：使用muduo C++网络库
08-17
《Linux多线程服务端编程：使用muduo C++网络库》主要讲述采用现代C++在x86-64 Linux上编写多线程TCP网络服务程序的主流常规技术，重点讲解一种适应性较强的多线程服务器的编程模型，即one loop per thread。...
c#学习笔记——学习心得
01-04
域：一个代表和某对象或类相关的变量的成员 字段：和属性相同，是用来存储对象的值，可以直接访问数据且不能对数据添加任何限制，但是属性不能且可以对数据添加访问限制。一个在类或结构的定义中声明的变量。可以被...
2021-10-14
lcx_1020的博客
10-14 280
深入理解程序编译和内存分配 转载自：https://blog.csdn.net/freeking101/article/details/78257914   From：http://blog.chinaunix.net/uid-22327815-id-3540305.html 从 Hello World 说程序运行机制：http://www.sohu.com/a/132798003_
C++--问题20--static局部变量、全局变量、成员变量、成员函数的生存周期和作用域
数组越界，数组进栈
10-12 256
C++--问题20--static局部变量、全局变量、成员变量、成员函数的生存周期和作用域 1.静态局部变量： 用于函数体内部修饰变量，这种变量的生存期长于该函数。 存在的意义就是随着第一次函数的调用而初始化，却不随着函数的调用结束而销毁。在第一次调用的时候初始化，且只初始化一次，也就是你第二次调用,不会继续初始化，而会直接跳过。 那么我们总结一下，静态局部变量的特点（与局部变量的对比）： （1）该变量在全局数据区分配内存(局部变量在栈区分配内存); （2）静态局部变量在程序执行到该对象的声明处时被首.
c++ static
761899457@qq.com
03-14 450
static 修饰成员变量 在函数内定义的静态成员变量，其作用域与普通成员变量一样，但是生命周期与整个程序一致。 对基本类型的静态局部变量若在声明时未赋以初值，则系统自动赋予0值。而对自动变量不赋初值，则其值是不定的。 static 修饰全局变量 静态全局变量的作用域只能是当前文件，而非静态的全局变量的作用域是整个程序（也就是各个源文件内都是有效的） static 修饰函数 可以限制此函数的作用域只是当前文件。 使用静态函数的好处是：不同的人编写不同的函数时，不用担心自己定义的函数，是否会与其它文件中的函数
java网络编程心得_【Java】 Java网络编程总结
weixin_33485981的博客
02-13 336
一.网络编程三要素：IP地址：每个设备在网络中的唯一标识。端口号：每个程序在设备上的唯一标识。协议：为计算机网络中进行数据交换而建立的规则或约定的集合。UDP: 面向无连接，数据不安全，速度快，不区分客户与服务端。TCP: 面向连接(三次握手)，数据安全，速度略低，分客户端和服务端。二.URI和URL以及URN：URI：是uniform resource identifier，统一资源标识符，用来...
java编程思想读书心得
努力上进的羊的博客
12-21 1181
Thinking In Java 写这篇文章的主要目的是记录java编程思想这本书的重点内容，一来可以分享给大家一起讨论学习，二来总结知识提升自己。 第一章：对象导论 1、java面向对象的理解： 将组成问题的各个元素都看着一个一个的简单对象，然后真对这些简单的对象封装成员，当遇到一个新的类似问题时，就可以通过这些简单对象来描述这个新的问题。这样就可以提高解决问题的效率，减少重复代码的开发。 2...
面向对象编程心得
极品小肥羊的博客
07-15 809
1、类之间的关系可以分为：关联、聚集、包容、继承。它们都是用来模拟现实生活中各个对象之间的关系的。 2、包容：即一个对象由另一个对象所专有。前者我们可以用内部类来模拟。 3、对于某些可能发生的运行时异常，比如：因找不到url所对应的文件而不知道返回什么等等情况，我们应该对 涉及到的方法（可能抛出异常） 或者是 用到的可能导致异常抛出的数据域   通过方法形式的封装来进行封装，并try-
函数式编程学习心得及教程
weixin_50964668的博客
02-22 441
函数式编程 前言 如果你已经从事开发有一段时间了，肯定多少对’函数式编程’有一定的了解，很多人包括我自己在还没有深入了解函数式编程的时候，基本都会有一个误解，函数式编程就是用很多function函数去编程你的代码。最近正好我在学函数式编程，于是就想着写一篇文章去向一些像我一样的初学者去解释一下函数式编程。 什么是函数式编程 我们来看一下百度百科对函数式编程的定义： 简单说，"函数式编程"是一种"编程范式"（programming paradigm），也就是如何编写程序的方法论。 它属于"结构化编程"的一种
Linux多线程编程学习心得
qq_44848795的博客
12-18 1537
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 为什么要有线程？ 如果说你现在是一个工厂的老板，工厂里有一条生产线。现在供不应求，必须扩大生产规模。如果是进程的角度，就是另外再键一个工厂，复制之前的生产线；但如果我直接在原来的工厂里增加几条生产线呢？那么这个扩建规模是不是要小很多，这种方式就是线程的方式 提示：以下是本篇文章正文内容，下面案例可...
Java入门1·2·3：一个老鸟的Java学习心得.PART3（共3个）
05-07
Java编程老鸟潜心写作，奉献高效率的Java学习心得 完全站在没有编程经验读者的角度，手把手教会读者学习Java 配16小时多媒体教学视频，高效、直观 一一击破Java入门可能会遇到的难点和疑惑 抽丝剥茧，层层推进，让...
JAVA入门1.2.3：一个老鸟的JAVA学习心得 PART1（共3个）
05-07
Java编程老鸟潜心写作，奉献高效率的Java学习心得 完全站在没有编程经验读者的角度，手把手教会读者学习Java 配16小时多媒体教学视频，高效、直观 一一击破Java入门可能会遇到的难点和疑惑 抽丝剥茧，层层推进，让...
HBase常用Java API
01-07
本节介绍与 HBase 数据存储管理相关的 Java API（基于 HBase 版本 1.2.3）。 HBase 的常用Java API HBase 主要包括 5 大类操作：HBase 的配置、HBase 表的管理、列族的管理、列的管理、数据操作等。 1）org.apache....
创建了一个静态数组，越界访问为什么不报错
weixin_30916125的博客
07-14 351
#include<stdio.h> int main() { int s[5],i; for( i=0;i<10;i++) { s[i]=i; } printf("\n"); for( i=0;i<10;i++) { printf("%d ",s[i])...
队列、栈
coco_astrids的博客
02-15 259
1. 队列 队列是一种特殊的线性结构，它只允许在队列的首部进行删除操作，称为“出队”；而在队列的尾部进行插入操作，称为“入队”；当队列中没有元素，即head==tail的时候，称为空队列。 例题：解密一组数6 3 1 7 5 8 9 2 4，规则是将第一个数删除，第二个数放在队列末尾，再将第三个数删除，把第四个数放到队列末尾......直到剩下最后一个数，将最后一个数也删除。最后把删除的数
win10笔记本WLAN已关闭，无法打开，解决办法
热门推荐
nyist_yangguang的博客
03-03 1万+
问题： or 方案： FN+F4 即可解决。
编程说明static成员和非static成员的不同使用方式
最新发布
05-10
静态成员变量是指在类中使用 static 关键字定义的成员变量，而非静态成员变量则是指没有使用 static 关键字定义的成员变量。 静态成员变量和非静态成员变量的使用方式有以下不同： 1. 访问方式：静态成员变量可以...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序猿的探索之路

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值