当前位置：首页 > article >正文

EX_25/2/24

article 2025/2/26 2:25:33

写一个三角形类，拥有私有成员 a,b,c 三条边写好构造函数初始化 abc 以及 abc 的set get 接口再写一个等腰三角形类，继承自三角形类 1：写好构造函数，初始化三条边 2：要求无论如何，等腰三角形类对象，总是等腰的再写一个等边三角形类，继承自等腰三角形类 1：写好构造函数，初始化三条边 2：要求无论如何，等腰三角形类对象，总是等边

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <unistd.h>
#include <sstream>
#include <vector>
#include <memory>

using namespace std;                 

class ABC
{
private:
	int a;
	int b;
	int c;
public:
	ABC(int a=0,int b=0,int c=0)
		:a(a),b(b),c(c)
	{}
	void seta(int l)
	{
		a=l;
	}
	void setb(int l)
	{
		b=l;
	}
	void setc(int l)
	{
		c=l;
	}
	int geta()
	{
		return a;
	}
	int getb()
	{
		return b;
	}
	int getc()
	{
		return c;
	}
};

class ABB:public ABC
{
public:
	ABB(int a=0,int bb=0)
		:ABC(a,bb,bb)
	{}
	void seta(int a)
	{
		ABC::seta(a);
		ABC::setb(a);
	}
	void setb(int b)
	{
		ABC::seta(b);
		ABC::setb(b);
	}
};
class AAA:public ABC
{
	AAA(int aaa=0)
		:ABC(aaa,aaa,aaa)
	{}
	void seta(int a)
	{
		ABC::seta(a);
		ABC::setb(a);
		ABC::setc(a);
	}
};
int main(int argc,const char** argv)
{
	ABB d;
	d.seta(4);
	d.setb(5);
	d.setc(6);

	AAA e;
	e.seta(7);
	return 0;
}

编写一个长方形类，私有成员 a,b 构造函数初始化 set get 接口编写一个正方形类，继承自长方形类构造函数初始化无论如何，正方形类对象总是正方形的

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <unistd.h>
#include <sstream>
#include <vector>
#include <memory>

using namespace std;                 

class AABB{
private:
    int a;
    int b;
public:
    AABB(int a=0,int b=0):a(a),b(b){};
    void setA(int l){a = l;}
    void setB(int l){b = l;}
    int getA(){return a;}
    int getB(){return b;}
};

class AA:public AABB{
public:
    AA() : AABB(0,0){}

    AA(int a)
        :AABB(a,a)
    {}

    void setA(int a){
        AABB::setA(a);
        AABB::setB(a);
    }

    void setB(int b){
        AABB::setA(b);
        AABB::setB(b);
    }
};


int main(int argc,const char** argv){
    AA a1;
    a1.setA(3);
    a1.setB(4);

}

封装消息队列 class Msg{ key_t key int id; int channel } 实现以下功能 Msg m("文件名") m[1].send("数据"),将数据发送到1号频道中 string str = m[1].recv(int size) 从1号频道中读取消息，并且返回把 send 改成 operator<< ,recv 改成 operator>> 实现效果: m[1] << "helloworld" 将 "helloworld" 写入消息队列的1号频道中 m[1] >> str 读取消息队列中1频道中的消息，存入 str 中

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <unistd.h>
#include <sstream>
#include <vector>
#include <memory>
#include <sys/ipc.h>
#include <sys/msg.h>

using namespace std;

class Msg {
private:
    key_t key;
    int id;
    int channel;
    struct msgbuf {
        long channel;
        char text[512];
    };

public:
    Msg(const string& filename = "") {
        key = ftok(filename.data(), 1);
        id = msgget(key, IPC_CREAT | 0666);
    }

    ~Msg() {
        msgctl(id, IPC_RMID, 0);
    }

    void send(const string& str) {
        msgbuf buf = {0};
        strcpy(buf.text, str.data());
        buf.channel = channel;
        msgsnd(id, &buf, strlen(buf.text) + 1, 0);
    }

    string recv(int size = 512) {
        msgbuf buf = {0};
        msgrcv(id, &buf, size, channel, 0);
        string str = buf.text;
        return str;
    }

    friend Msg& operator<<(Msg& msg, const string& str);
    friend Msg& operator>>(Msg& msg, string& str);

    Msg& operator[](int channel) {
        this->channel = channel;
        return *this;
    }
};

Msg& operator<<(Msg& msg, const string& str) {
    msg.send(str);
    return msg;
}

Msg& operator>>(Msg& msg, string& str) {
    str = msg.recv();
    return msg;
}

int main(int argc, const char** argv) {

    return 0;
}

封装信号灯集 class Sem{ key_t key int id; int index } 实现以下功能 Sem s(参数x，参数y):创建信号灯集，信号灯集中存在 x 个信号量，并且将所有信号量初始化为 y s[1].init(10):手动初始化信号灯集中的第1个信号量，初始化成 10 s[1] + 1 让信号灯集中的第1个信号量的值 +1 s[1].operator+(1) s[1] - 1 让信号灯集中的第1个信号量的值 -1 追加 operator ++ 功能，即解锁一次以及 operator-- 功能，即上锁一次

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <unistd.h>
#include <sstream>
#include <vector>
#include <memory>
#include <sys/ipc.h>
#include <sys/sem.h>

using namespace std;

class Sem {
private:
    key_t key;
    int id;
    int index;

public:
    Sem(const string& filename = "", int n, int val) {
        key = ftok(filename.data(), 1);
        id = semget(key, n, IPC_CREAT | 0666);
        for (int i = 0; i < n; i++) {
            semctl(id, i, SETVAL, val);
        }
    }

    ~Sem() {
        semctl(id, 0, IPC_RMID);
    }

    friend Sem& operator+(const Sem& l, int val);
    friend Sem& operator-(const Sem& l, int val);
    friend Sem& operator++(Sem& l);
    friend Sem& operator--(Sem& l);
    friend Sem& operator[](Sem& l, int index);
};

Sem& operator+(Sem& l, int val) {
    sembuf buf = {0};
    buf.sem_num = l.index;
    buf.sem_op = abs(val);
    buf.sem_flg = SEM_UNDO;
    semop(l.id, &buf, 1);
    return l;
}

Sem& operator-(Sem& l, int val) {
    sembuf buf = {0};
    buf.sem_num = l.index;
    buf.sem_op = -abs(val);
    buf.sem_flg = SEM_UNDO;
    semop(l.id, &buf, 1);
    return l;
}

Sem& operator++(Sem& l) {
    sembuf buf = {0};
    buf.sem_num = l.index;
    buf.sem_op = 1;
    buf.sem_flg = SEM_UNDO;
    semop(l.id, &buf, 1);
    return l;
}

Sem& operator--(Sem& l) {
    sembuf buf = {0};
    buf.sem_num = l.index;
    buf.sem_op = -1;
    buf.sem_flg = SEM_UNDO;
    semop(l.id, &buf, 1);
    return l;
}
Sem& operator[](const Sem& l,int index){
	l.index = index;
	return l;
}
int main(int argc, const char** argv) {
   
    return 0;
}

查看全文

http://www.kler.cn/a/561136.html