创建一个存储过程，在输入emp表中某个雇员的姓名后，根据雇员的姓名，返回该雇员的薪水并输出（用out参数）。

好的，这是一个关于数据库的技术问题，我可以为您提供帮助。以下是该存储过程的代码示例：

CREATE PROCEDURE getSalary
@name nvarchar(50),
@salary money out
AS
BEGIN
SET @salary = (SELECT Salary FROM emp WHERE Name = @name)
SELECT @salary AS Salary
END

您可以将该代码复制到 SQL Server Management Studio 中，并将其执行即可。调用方式如下：

DECLARE @salary money;
EXEC getSalary 'John', @salary out;
PRINT @salary;

其中，'John' 是您要查询的雇员姓名。希望这个回答能够帮助到您。

相关问题

在主函数中创建一个容器用来管理公司各种雇员对象，多态地计算并输出每个雇员的工资。

好的，我可以帮你写出代码实现这个功能。以下是一个示例程序：

#include <iostream>
#include <vector>
#include "employee.h"
#include "manager.h"
#include "engineer.h"
#include "salesman.h"

int main() {
    std::vector<Employee*> employees;

    Manager* manager1 = new Manager("John Smith", 10000, 0.05);
    Manager* manager2 = new Manager("Jane Doe", 12000, 0.06);
    Engineer* engineer1 = new Engineer("Bob Johnson", 8000, 1000);
    Engineer* engineer2 = new Engineer("Alice Brown", 9000, 1500);
    Salesman* salesman1 = new Salesman("Mike Davis", 6000, 0.1, 50000);
    Salesman* salesman2 = new Salesman("Sara Parker", 7000, 0.12, 60000);

    employees.push_back(manager1);
    employees.push_back(manager2);
    employees.push_back(engineer1);
    employees.push_back(engineer2);
    employees.push_back(salesman1);
    employees.push_back(salesman2);

    for (Employee* emp : employees) {
        std::cout << "Employee " << emp->getName() << " earned $" << emp->calculateSalary() << std::endl;
    }

    for (Employee* emp : employees) {
        delete emp;
    }

    return 0;
}

在这个示例程序中，我们创建了一个 `std::vector<Employee*>` 类型的容器 `employees` 来存储公司各种雇员对象。我们向这个容器中添加了两个经理对象 `manager1` 和 `manager2`，两个工程师对象 `engineer1` 和 `engineer2`，以及两个销售员对象 `salesman1` 和 `salesman2`。

然后，我们使用 for 循环遍历容器中的每个雇员对象，并且通过多态的方式调用每个对象的 `calculateSalary()` 函数来计算工资，并输出到屏幕上。最后，我们再次使用 for 循环遍历容器中的每个雇员对象，并且使用 `delete` 关键字释放这些对象所占用的内存。

在这个示例程序中，我们还需要编写 `Employee`、`Manager`、`Engineer` 和 `Salesman` 四个类的定义文件，以及实现每个类的成员函数。下面是一个可能的实现：

// employee.h
#ifndef EMPLOYEE_H
#define EMPLOYEE_H

#include <string>

class Employee {
public:
    Employee(const std::string& name, double baseSalary);
    virtual ~Employee();

    virtual double calculateSalary() const;

    const std::string& getName() const;
    double getBaseSalary() const;

private:
    std::string name;
    double baseSalary;
};

#endif // EMPLOYEE_H


// employee.cpp
#include "employee.h"

Employee::Employee(const std::string& name, double baseSalary)
    : name(name), baseSalary(baseSalary) {}

Employee::~Employee() {}

double Employee::calculateSalary() const {
    return baseSalary;
}

const std::string& Employee::getName() const {
    return name;
}

double Employee::getBaseSalary() const {
    return baseSalary;
}


// manager.h
#ifndef MANAGER_H
#define MANAGER_H

#include "employee.h"

class Manager : public Employee {
public:
    Manager(const std::string& name, double baseSalary, double bonusRate);

    double calculateSalary() const override;

private:
    double bonusRate;
};

#endif // MANAGER_H


// manager.cpp
#include "manager.h"

Manager::Manager(const std::string& name, double baseSalary, double bonusRate)
    : Employee(name, baseSalary), bonusRate(bonusRate) {}

double Manager::calculateSalary() const {
    return getBaseSalary() * (1 + bonusRate);
}


// engineer.h
#ifndef ENGINEER_H
#define ENGINEER_H

#include "employee.h"

class Engineer : public Employee {
public:
    Engineer(const std::string& name, double baseSalary, double bonus);

    double calculateSalary() const override;

private:
    double bonus;
};

#endif // ENGINEER_H


// engineer.cpp
#include "engineer.h"

Engineer::Engineer(const std::string& name, double baseSalary, double bonus)
    : Employee(name, baseSalary), bonus(bonus) {}

double Engineer::calculateSalary() const {
    return getBaseSalary() + bonus;
}


// salesman.h
#ifndef SALESMAN_H
#define SALESMAN_H

#include "employee.h"

class Salesman : public Employee {
public:
    Salesman(const std::string& name, double baseSalary, double commissionRate, double sales);

    double calculateSalary() const override;

private:
    double commissionRate;
    double sales;
};

#endif // SALESMAN_H


// salesman.cpp
#include "salesman.h"

Salesman::Salesman(const std::string& name, double baseSalary, double commissionRate, double sales)
    : Employee(name, baseSalary), commissionRate(commissionRate), sales(sales) {}

double Salesman::calculateSalary() const {
    return getBaseSalary() + commissionRate * sales;
}

在这个实现中，我们定义了 `Employee` 类作为基类，其他三个类分别继承自 `Employee` 类，实现了各自的工资计算方法。注意到 `calculateSalary()` 函数被声明为 `virtual`，这就允许我们通过指向基类的指针来调用派生类的函数，实现了多态的效果。

用Oracle编写程序，输入一个雇员编号，显示该雇员编号、姓名、工资、奖金、工作职位、部门编号

好的，以下是一个简单的Oracle PL/SQL程序，可以实现您的需求：

DECLARE
  v_empno EMP.EMPNO%TYPE;
  v_ename EMP.ENAME%TYPE;
  v_sal EMP.SAL%TYPE;
  v_comm EMP.COMM%TYPE;
  v_job EMP.JOB%TYPE;
  v_deptno EMP.DEPTNO%TYPE;
BEGIN
  -- 获取输入的雇员编号
  v_empno := &enter_empno;

  -- 查询雇员信息
  SELECT EMPNO, ENAME, SAL, COMM, JOB, DEPTNO
  INTO v_empno, v_ename, v_sal, v_comm, v_job, v_deptno
  FROM EMP
  WHERE EMPNO = v_empno;

  -- 显示雇员信息
  DBMS_OUTPUT.PUT_LINE('雇员编号：' || v_empno);
  DBMS_OUTPUT.PUT_LINE('雇员姓名：' || v_ename);
  DBMS_OUTPUT.PUT_LINE('工资：' || v_sal);
  DBMS_OUTPUT.PUT_LINE('奖金：' || v_comm);
  DBMS_OUTPUT.PUT_LINE('工作职位：' || v_job);
  DBMS_OUTPUT.PUT_LINE('部门编号：' || v_deptno);
END;

当您运行程序时，程序会要求您输入一个雇员编号。然后，程序会查询EMP表，找到该雇员的信息，并将其显示在控制台上。请注意，此程序使用了Oracle PL/SQL中的变量、SELECT INTO语句和DBMS_OUTPUT.PUT_LINE语句。