اختبر قدراتك في C/CPP - الحلقة الرابعة, الجزء الثاني

أجل, أجل, الناتج موجه. هههههه, يا للفضيحة :lol:

المهم, 4 ملفات:

#include<stdio.h>
#include<cassert>

class CVector
{
private:
	float m_pfVector[3];
public:
	void printVector();
	float& operator[](int index);
	CVector(){m_pfVector[0]=m_pfVector[1]=m_pfVector[2]=0;};
	CVector(float x, float y, float z){
		m_pfVector[0] = x;
		m_pfVector[1] = y;
		m_pfVector[2] = z;
	}
	~CVector(void){}
};

void CVector::printVector(){
	for(int i=0; i<3; i++)
		printf("%-10.2f", m_pfVector);
}

float& CVector::operator[](int index){
	assert(index>=0&&index<3);
	return m_pfVector[index];
}

class CMatrix
{
private:
	float m_pfMatrix[3][3];
public:
	float& operator()(int x, int y);
	CMatrix(float matrix[3][3]);
	~CMatrix(void){}
};

CMatrix::CMatrix(float matrix[3][3]){
	for(int i=0; i<3; i++)
		for(int j=0; j<3; j++)
			m_pfMatrix[j]=matrix[j];
}

float& CMatrix::operator()(int x, int y){
	assert(x>=0&&x<3);
	assert(y>=0&&y<3);
	return m_pfMatrix[x][y];
}

#include"Vector.h"
#include"Matrix.h"

void prod(CMatrix m, CVector v, CVector &resultV){
	int i, j;
	for(i=0; i<3; i++)
		for(j=0; j<3; j++)
			resultV = resultV + m(i,j)*v[j];
}

#include<stdio.h>
#include<conio.h>
#include"prod.h"


int main(){
	CVector resultV, vector(2, 4, 3);
	float m[3][3] = {{1,4,1},{2,1,3},{5,2,2}};
	CMatrix matrix(m);
	prod(matrix, vector, resultV);
	resultV.printVector();
	_getch();
	return 0;
}

المخرجات:

21.00     17.00     24.00

جداء مصفوفة بمتجه ينتج عنه متجه و ليس مصفوفة.

شرط الجداء هو أن يكون عدد أعمدة المصفوفة مُساوي لعدد صفوف المتجه.

مثال :

محاولتي :

#include <iostream>
using namespace std;
class matrice;

class vect {
    double v[3];
public:

    vect(double v1 = 0, double v2 = 0, double v3 = 0) {
        v[0] = v1;
        v[1] = v2;
        v[2] = v3;
    }

    void affiche() {
        int i;
        for (i = 0; i < 3; i++) cout << v << " ";
        cout << endl;
    }
    friend vect prod(const matrice &, const vect &);
};

#include <iostream>
using namespace std;
class vect;

class matrice {
    double mat[3] [3];
public:
    matrice();

    matrice(double t [3] [3]) {
        int i;
        int j;
        for (i = 0; i < 3; i++)
            for (j = 0; j < 3; j++)
                mat [j] = t [j];
    }
    friend vect prod(const matrice &, const vect &);
};

#include "Vect.h"
#include "Mat.h"

vect prod(const matrice & m, const vect & x) {
    int i, j;
    double som;
    vect res;
    for (i = 0; i < 3; i++) {
        for (j = 0, som = 0; j < 3; j++)
            som += m.mat [j] * x.v[j];
        res.v = som;
    }
    return res;
}

#include "Prod.h"

int main() {
    vect w(1, 2, 3);
    vect res;
    double tb [3][3] = {1, 2, 3, 4, 5, 6, 7, 8, 9};

    matrice a = tb;
    res = prod(a, w);
    res.affiche();

    return 0;
}

بسم الله الرحمن الرحيم

بداية أحب أن أعلن أنني أكره المتغيرات من نوع double كل شيء فيها غامض بالنسبة لي ... كيف تخزن ..

وما هي حدودها ولماذا .. فيها قيم عجيبة ...في الحقيقة دائماً أستخدم float قرأت مرة في كتاب عن جافا أن double حدودها العليا في الدقة هي : 1.8*10703 أوشيئاً كذا ..فهل هذا صحيح ؟؟؟

المهم :

هذه محاولتي على int ... ولا أعلم عندما أحول المتغيرات إلى double يطلعلي حاجات عجيبة ...

vector.h

class vect  {
public:
    	int V[3];
    	vect(int a=0,int b=0,int c=0) {
    	V[0] = a;
    	V[1] = b;
    	V[2] = c;
    	}
    	vect(int a[3])
    	{
            	for(int i=0;i<3;i++)
                    	V=a;
    	}
    	void Show(int(*_printf)(const char*,...)) 
    	{
            	_printf("\nvect ={%d,%d,%d};\n",V[0],V[1],V[2]);
    	}
		int get(int i)
		{
			return V;
		}
};

matrix.h

class matrice 
{
private:
	int M[3][3];
public:
    	matrice (int a[3][3])
    	{
            	for(int i=0;i<3;i++)
                    	for(int j=0;j<3;j++)
                            	M[j]=a[j];
    	}
    	void Show(int(*_printf)(const char*,...))
    	{
            	_printf("matrice ={");
            	_printf("{%i,%i,%i},",M[0][0],M[0][1],M[0][2]);
            	_printf("{%i,%i,%i},",M[1][0],M[1][1],M[1][2]);
            	_printf("{%i,%i,%i}};\n",M[2][0],M[2][1],M[2][2]);
    	}
		int get(int i,int j)
		{
			return M[j];
		}
};

prod.h

#include"vector.h"
#include"matrix.h"
vect prod (matrice m,vect v)
{
    	int result[3]={0};
    	for(int i=0;i<3;i++)
            	for(int j=0;j<3;j++)
                    	result+=m.get(i,j)*v.get(j);
    	vect R=result;
    	return R;
}

main.cpp

#include <cstdio>
#include"prod.h"
int main() {
    	vect a(1,2,1);
    	a.Show(printf);
    	int B[3][3]={{1,1,1},{1,1,1},{1,1,1}};
    	matrice b(B);b.Show(printf);
    	vect c=prod(b,a);
    	printf("after prod");c.Show(printf);
       	return 0;
}

يمكنكم رؤية البرنامج عندما يكون double بدل int والأشياء العجيبة فيه ؟!!WHY.rar

الدالة prod يجب أن يكون بإمكانها الوصول إلى بيانات كلا الفئتين, لذا كانت فكرة السؤال تكمن في الإعلان عن prod كدالة صديقة للصنفين معا. :)

تم منح النقاط للمشاركات المفيدة و حذف الردود الغير مفيدة, حفاظا على تنسيق الموضوع.

يُغلق.

أراكم في الجزء الثالث من الحلقة الرابعة.