prof编程

⑤ linux 的多线程编程中，如何给线程发信号

不管是在进程还是线程，很多时候我们都会使用一些定时器之类的功能，这里就定时器在多线程的使用说一下。首先在linux编程中定时器函数有alarm()和setitimer(),alarm()可以提供一个基于秒的定时功能，而setitimer可以提供一个基于微妙的定时功能。

alarm()原型：
#include <unistd.h>
unsigned int alarm(unsigned int seconds);

这个函数在使用上很简单，第一次调用这个函数的时候是设置定时器的初值，下一次调用是重新设置这个值，并会返回上一次定时的剩余时间。

setitimer()原型：
#include <sys/time.h>
int setitimer(int which, const struct itimerval *value,struct itimerval *ovalue);

这个函数使用起来稍微有点说法，首先是第一个参数which的值，这个参数设置timer的计时策略，which有三种状态分别是：

ITIMER_REAL：使用系统时间来计数，时间为0时发出SIGALRM信号，这种定时能够得到一个精准的定时，当然这个定时是相对的，因为到了微秒级别我们的处理器本身就不够精确。

ITIMER_VIRTUAL：使用进程时间也就是进程分配到的时间片的时间来计数，时间为0是发出SIGVTALRM信号，这种定时显然不够准确，因为系统给进程分配时间片不由我们控制。

ITIMER_PROF：上面两种情况都能够触发

第二个参数参数value涉及到两个结构体：

struct itimerval {
struct timeval it_interval; /* next value */
struct timeval it_value; /* current value */
};

struct timeval {
long tv_sec; /* seconds */
long tv_usec; /* microseconds */
};

在结构体itimerval中it_value是定时器当前的值，it_interval是当it_value的为0后重新填充的值。而timeval结构体中的两个变量就简单了一个是秒一个是微秒。

上面是这两个定时函数的说明，这个函数使用本不是很难，可以说是很简单，但是碰到具体的应用的时候可能就遇到问题了，在多进程编程中使用一般不会碰到什么问题，这里说的这些问题主要体现在多线程编程中。比如下面这个程序：

#include <pthread.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/time.h>

void sig_handler(int signo)
{
alarm(2);
printf("alarm signal\n");
}

void *pthread_func()
{
alarm(2);
while(1)
{
pause();
}
}

int main(int argc, char **argv)
{
pthread_t tid;
int retval;

signal(SIGALRM, sig_handler);

if((retval = pthread_create(&tid, NULL, pthread_func, NULL)) < 0)
{
perror("pthread_create");
exit(-1);
}

while(1)
{
printf("main thread\n");
sleep(10);
}
return 0;
}
这个程序的理想结果是：
main thread
alarm signal
alarm signal
alarm signal
alarm signal
alarm signal
main thread
可事实上并不是这样的，它的结果是：
main pthread
alarm signal
main pthread
alarm signal
main pthread

⑥ 用C++编程怎样实现对数据的存储和删除，求一个实例

---------------------------------------输出----------------------------------------
#include<fstream>
//实现文件储存和读取的头文件
#include<iostream>
using
namespace
std;
int
main()
{
int
a[5]={1,2,3,4,5};
//加入要储存的是这些数据
ofstream
output;
//输出流
output.open("test.txt");
//打开test.txt，若没有，则自动创建
for(int
i=0;i<5;++i)
output<<a[i]<<endl;
//输出数据，两个数据间用分隔符换行，进行分隔
output.close();
//输出完毕，关闭文件
return
0;
}
-----------------------------读取--------------------------------
#include<fstream>
#include<iostream>
using
namespace
std;
int
main()
{
int
readin[5];
//储存数据的数组
ifstream
input;
//输入流
input.open("test.txt");
//打开文件，若文件不存在，那么input.fail()会返回true
此处不进行判断是因为上面已经创建了test.txt
for(int
i=0;i<5;++i)
input>>readin[i];
for(int
i=0;i<5;++i)
cout<<readin[i]<<"
";
cout<<endll
input.close();
return
0;
}
这是一个简单的实例，具体的你需要可以再问我

⑦ Visual Studio 2015 各个版本有什么区别

Visual Studio 2015有三个版本：社区版、Professional、企业版。接下来详细介绍一下三个版本的区别：

1、社区版不支持企业使用，两外两个版本支持所有主体使用

⑧ 问一道c语言编程中链表的题目

#include <time.h>

time_t timer;

time(&timer);

struct tm *tm_val = gmtime( const time_t *timer);

char * stra = ctime(&timer);

char * strb = asctime(tm_val);

time_t 与系统实现有关，一般为long，自1970-01-01 00:00:00(Epoch)到现在的秒数

struct tm{

int tm_sec;

int tm_min;

int tm_hour;

int tm_mday; //本月的第[1, 31]天

int tm_mon; //本月第[0, 11]月

int tm_year; //该值为 实际年份-1900

int tm_wday; //周[0, 6] 周日为0

int tm_yday; //是本年的第[0, 365]天

int tm_isdst; //夏令时标志

};

其它类似 localetime(), strftime(), 以及宽字符版的wcsftime()都只是输出变体

*除了time()，其它函数都不是线程安全的， POSIX扩展指定了相对应的线程安全函数

时钟

struct timespec tpstart;

int err = clock_gettime(CLOCK_REALTIME, &tpstart); //获取系统时钟

struct timespec{

time_t tv_sec; //秒

long tv_nsec; //纳秒(1微秒=1000纳秒)

};

int err = nanosleep(……); //可替代sleep(), usleep(), 且不会影响包括SIGALRM在内的任何信号的使用

--------------------------------------------------------------------------------

--------------------------------------------------------------------------------

#include <sys/time.h>

struct timeval{

time_t tv_sec; //存储秒

time_t tv_usec; //存储微秒 (1秒=1000毫秒=1000000微秒)

};

struct timeval *now;

int err = gettimeofday(now, NULL);

此时，now->tv_sec 表示自Epoch以来的秒数，now->tv_usec 表示自Epoch以来的微秒数

要记录进程运行的时间

clock_t times(struct tms *buffer); //buffer中详细记录了进程的各项详细时间

--------------------------------------------------------------------------------

--------------------------------------------------------------------------------

间隔计时器：

“过1个小时后吃第一次药，然后每隔4个小时吃一次药。”

struct itimerval{ //itimerval

struct timeval it_value; //初始间隔

struct timeval it_interval; //重复间隔

};

int ret = setitimer(int which, const struct itimerval *newval, struct itimerval *oldval);

getitimer(……);

which: ITIMER_REAL, ITIMER_VIRTUAL, ITIMER_PROF //进程常备的三个时钟

Example： CPU时间每过2s，打印一个数字

#include <errno.h>

#include <signal.h>

#include <unistd.h>

#include <stdio.h>

#include <stdlib.h>

#include <sys/time.h>

enum { MAX_VALUE = 20 };

int main(){

int setupinterrupt(void);

int setupitimer(void);

if(setupinterrupt() == -1){

perror("setupinterrupt error");

return 1;

}

if(setupitimer() == -1){

perror("setupitimer error");

return 1;

}

while(1); //不好的代码，仅仅演示

}

/* 发生CPU时钟信号时，打印数字*/

static void handler(int signo){

static int tick = MAX_VALUE;

int err = errno;

fprintf(stderr, "%d. ", tick);

errno = err;

if(tick <= 0){

write(STDERR_FILENO, "Done.", strlen("Done."));

exit(0);

}

}

/* 安装CPU时间中断信号 */

int setupinterrupt(){

struct sigaction act;

act.sa_handler = handler;

act.sa_flags = 0;

return (sigemptyset(&act.sa_mask) && sigaction(SIGPROF, &act, NULL));

}

/* 设置间隔时间计时器为2.0ss，初始间隔等于重复间隔*/

int setupitimer(){

struct itimerval tm;

tm.it_interval.tv_sec = 2;

tm.it_interval.tv_usce = 0;

tm.it_value = tm.it_interval;

return setitimer(ITIMER_PROF, &tm, NULL);

}

-------------------------------------------------------------------------------------------------MR_Computer

⑨ 如何学好一门编程语言

学好一门编程语言是十分不容易的，但是如果学会了，它的实用性是很强的，下面我为大家整理了学好一门编程语言的办法，大家可以参考借鉴。

如何学好一门编程语言?

一、多总结

多总结才能加深理解、增强记忆。举例，Go 中有 slice、map、channal 类型，它们都可以用 make 生成实例，但 slice 和 map 还可以用以下形式初始化，也是编程规范中建议的初始化方式：

colors := map[string]string{}

slice := []int{}

但注意了，channal 则没有这样的语法：msg := chan string{}

上面两句是生成实例，表示空集合，但下面两句则表示实例不存在，值为 nil

var colors map[string]string

var slice []int

另外，结构体指针 slice 还可以象下面这样初始化，结构体实例不用明确地指定类型(使用了类型推导)、不用明确地取地址运算(&)。

type Proct struct {

name string

price float64

}

procts := []*Proct{{"Spanner", 3.99}, {"Wrench", 2.49}, {"Screwdriver", 1.99}}

看到没有，如果不经常总结，这一圈学下来会把你整的稀里糊涂的。

二、多比较

学一门新语言一定要与你之前已经熟悉的语言经常作比较，找出它们的相同与不同，这样才能加深记忆和理解，否则学完之后脑子里会一片混乱，搞不清谁是谁非了。

就拿数组来说吧，在 Java、Scala、Go 中定义、实例化、赋值是不一样的。

//Java

int[] arr;//定义数组，不可以指定数组长度

arr = new int[5];//创建数组对象(实例化)，指定数组长度

arr[1] = 8;//赋值

//Scala

val arr = new Array[Int](5) //数组在Scala里用的是泛型类，构造函数参数指定数组大小

arr(1) = 8 //赋值，注意用的是括号

//Go

arr := [5]int{} //创建数组，初始化5个元素都为0，注意如果不指定数组长度，则是另外一种类型Slice

arr[1] = 8 //赋值

再比如 Map 在 Scala 与 Go 语言里定义、初始化、访问也是不同的，作了以下比较后印象会非常深刻，把它们记下来，这样以后使用就不会搞混了。

//Scala

val capital = Map("France" -> "Paris", "Japan" -> "Tokyo")

println(capital.get("France"))

//Go

capital := map[string]string{"France": "Paris", "Japan": "Tokyo"}

fmt.Println(capital["France"])

Go 同时给多个变量赋值在 Scala 里可以用模式匹配做到，如下：

//Scala(使用样本类的模式匹配)

case class Tao(name: String, age: Int);

val Tao(myName, myAge) = Tao("taozs", 18);

println(myName)

println(myAge)

//Go

myName, myAge := "taozs", 18

fmt.Println(myName)

fmt.Println(myAge)

//Scala(使用元组的模式匹配)

val (myNumber, myString) = (123, "abe")

println(myNumber)

println(myString)

//Go

myNumber, myString := 123, "abe"

fmt.Println(myNumber)

fmt.Println(myString)

以下是 Scala 和 Go 定义和实现函数的区别：

//Scala

val increase: Int => Int = (x: Int) => x + 1

println(increase(8))

//Go

var increase func(int) int = func(x int) int { return x + 1 }

fmt.Println(increase(8))

除了在 Scala 和 Go 里都可以类型推导外，在 Scala 里还可以这样定义函数：

//Scala

val increase = (_: Int) + 1

为方便自己将来随时查阅，可以建立下面这样的对比表格，描述不一定要求规范，自己能看懂就行。

三、转变思维方式，

学会用这门语言去思考

学会用语言去思考是关键。如果你以前是学 C 的，转学 Java，你一定要改变以前面向过程的思维，学会用面向对象的思维去分析问题;以前学 Java 的，转学 Scala 则要学会用函数式的编程思维解决问题。

举一个函数式编程的例子，以下是 Java 语言常用的 for 循环，循环变量从 1 到 10 执行 10 次循环体：

// 命令式编程

for (int i = 1; i < 10; i++) {

// 此处是循环体做10次

}

这被称为命令式编程 (Imperative Programming)，但学了 Scala 的函数式编程 (Functional Programming) 后，解决同样的问题，我们可以换一种思维：构建 1 到 10 的列表序列，针对列表中的`每个元素分别执行函数，如下：

//函数式编程

val autoList = (1 to 10).map(i => /*此处是函数体，针对1到10的每一个分别调用 1次*/)

已经习惯了 Java 编程的，对 Scala 的函数式编程、样本类、模式匹配、不可变对象、隐式转换等需要一个逐步适应的过程，要渐渐学会用它们思考和解决问题。

再举个 Scala 与 Go 思维方式不同的例子，要实现对一个字符串里的每个字符加 1 的操作，Scala 里可以这样：

"abc".map(cc => cc + 1)

"abc"是一个字符串对象，调用它的方法 map，这是纯面向对象的思维，但在 Go 里就要转变为面向过程的思维：

name := "abc"

second := strings.Map(func(x rune) rune {

return x + 1

}, name)

注意，这里的 strings 是包 (package)，调用它的公共函数 Map，被人操作的对象 name 字符串作为函数参数传入。Go 提供的函数 len、cap、append、 等其实都是面向过程的，虽然 Go 也提供有面向对象的支持，已经习惯了面向对象编程的，刚开始学 Go 语言需要特别留意这一点。

四、多看开源代码

学一门语言就是学一种思维方式，如今 GitHub 上可下载的开源代码海量级，通过看别人的代码，学习别人是如何解决问题的，养成用该语言思考的习惯，另外还能学习到一些非常有用的技巧，比如我在看一个 Go 语言性能测试框架代码时看到有以下写法：

func main() {

defer profile.Start().Stop()

...

}

这个意思是指刚进入程序时执行 Start( ) 函数，程序退出前调用 Stop( ) 函数，非常好的技巧啊!可以用于需要在程序执行前和程序完成后分别执行一段逻辑的场景。再看 Start( ) 函数是怎么实现的：

func Start(options ...func(*Profile)) interface {

Stop()

} {

...

return &prof

}

该函数返回了一个实现了含有 Stop( ) 函数接口的对象，如此才能在调用 Start 调用后连调 Stop。

五、优先学会使用代码分析工具

代码分析的工具包括静态检查、测试、测试覆盖率分析、性能分析(内存、CPU)、调试工具等，工具的价值在于它可以有效帮我们发现代码问题，这在我们刚开始学一门编程语言时意义尤其重大。

例如，以下这句 Java 赋值语句估计没有哪本教科书会告诉你有性能问题：

String sb = new String(“Hello World”);

以下这段 Java 代码你也不一定能意识到有多线程问题：

synchronized public void send(authuserPacket pkt, Thread t, String flowNo) throws IOException

{

logger.info("start");

//连接不可用，直接抛出异常，等待接收线程连接服务器成功

if (!this.avaliable)

{

try

{

//如果连接不可用，则等待2S，然后重新检测

Thread.sleep(2000);

}

... ...

如果我们及时用 FindBugs 工具检查就会发现上面这些问题，进而你会去分析研究为什么，如此，你对这门语言的了解也会越来越多。

另外，Go 语言自带的 vet/test/cover/pprof/trace 都是非常有用的工具，一边学一边使用这些工具分析代码，能加深对语言的理解。

六、多练习、多实践

就象学自然语言一样，如果只知道语法不去练是没有任何效果的，只有反复地练习，慢慢才能变成自己的一项技能。书本上的例子代码最好能从头到尾亲自敲一遍，多运行、多尝试，另外再找一些题目来练习，如能有机会参与项目开发则更好啦，勤动手、勤实践是最好的学习方法。

其它的方法还有：

做好笔记，把学习中遇到的关键点和自己的思考记下来，便于后面复习和对比;

复习，学习一定要重复、重复、再重复;

学习贵在坚持，每天学一点(比如坚持每天学 1 小时)，日积月累。

⑩ C++编程题

哇，这么巧？我今天刚做了这个题目微。。。
#include <iostream.h>
#include <iomanip.h>

class Person
{
public:
void input()
{
cout << "number:";
cin >> number;
cout << "name:";
cin >> name;
}
void display()
{
cout << "number" << number << endl;
cout << "name" << name << endl;
}
private:
int number;//编号
char name[100];//姓名
};

class Student : public Person
{
public:
void input()
{
cout << "depart:";
cin >> depart;
cout << "degree:";
cin >> degree;
}
void display()
{
cout << "depart" << depart << endl;
cout << "degree" << degree << endl;
}
private:
int degree;//班级号
int depart;//成绩
};

class Teacher : public Person
{
public:
void input()
{
cout << "prof:";
cin >> prof;
cout << "depart:";
cin >> depart;
}
void display()
{
cout << "prof" << prof << endl;
cout << "depart" << depart << endl;
}
private:
char prof[100];//职称
char depart[100];//部门
};

int main()
{
Student s1;
Teacher t1;
cout << "Input a student data:\n";
s1.Person::input();
s1.input();
cout << "Input a teacher data:\n";
t1.Person::input();
t1.input();

cout << "Output a student data:\n";
s1.Person::display();
s1.display();
cout << "Output a teacher data:\n";
t1.Person::display();
t1.display();

return 0;
}