C compiles and runs fine but I can't generate any types of C outputs after certain point in-CodePudding

The code starts with declaring various arrays with a size that is pre-calculated, and will be used in the rest of the program. However, after a certain point in the list of declarations, C will fail to generate any output even after a successful compilation. After the comment in the middle of the code, no outputs can be generated. I have tried simple outputs like "cout" and writing in a file.

Edit: I have added a sample output written by one of the answers to demonstrate. The program just runs and does not generate anything. This is the terminal output: "

PS C:\Users\umroot.COLLAR\projects\CrackHole> g   .\Peridynamics.cpp -o peri
PS C:\Users\umroot.COLLAR\projects\CrackHole> .\peri.exe
PS C:\Users\umroot.COLLAR\projects\CrackHole>

#include <math.h>
#include <iostream>
#include <vector>
#include <string>
#include <conio.h>

// #include "Ellipse.h"
#include <fstream>

using namespace std;

int main () {
    float length = 0.5;
    float width = 0.5;
    float radiusMajor = 0.05;
    float radiusMinor = 0.05;
    double ellipseCurvature = radiusMinor * radiusMinor / radiusMajor;
    float radiusPath = 0.08;
    int dt = 1;
    const double ELASTIC_MODULUS = 200e9;
    const float POISSON_RATIO = 0.3;
    const int NumofDiv_x = 100;
    const int NumofDiv_y = 100;
    int timeInterval = 2500;
    const double appliedPressure = 500e7;
    int initialTotalNumMatPoint = NumofDiv_x * NumofDiv_y;
    int maxFam = 200;
    float dx = length / NumofDiv_x;
    float delta = 3.015 * dx;
    float thick = dx;
    float volCorrRadius = dx / 2;
    const double SHEAR_MODULUS = ELASTIC_MODULUS / (2 * (1   POISSON_RATIO));
    const double BULK_MODULUS = ELASTIC_MODULUS / (2 * (1 - POISSON_RATIO));
    const double ALPHA = 0.5 * (BULK_MODULUS - 2 * SHEAR_MODULUS);
    float area = dx * dx;
    float volume = area * thick;
    const float BCD = 2 / (M_PI * thick * pow(delta, 4));
    int temp = floor(9 * M_PI * initialTotalNumMatPoint);
    float nodeFam[100000][3] = {0.0};
    int nnum = 0;
    float coord_excess[initialTotalNumMatPoint][2] = {0.0};
    int path_horizontal[NumofDiv_x] = {0};
    // Ellipse centerHole(0, 0, radiusMajor, radiusMinor);
    // Ellipse leftTip((-1) * radiusMajor, 0, 0.005, 0.005);
    // Ellipse rightTip(radiusMajor, 0, 0.005, 0.005);
    float coordx = 0.0;
    float coordy = 0.0;
    int counter = 0;
    for (int i = 0; i < NumofDiv_x; i  ) {
        for (int j = 0; j < NumofDiv_y; j  ) {

            coordx = (length / 2) * (-1)   (dx / 2)   i * dx;
            coordy = (width / 2) * (-1)   (dx/2)   j * dx;
            // if (centerHole.InEllipse(coordx, coordy)){
            //     continue;
            //  }

             if (abs(coordy) <= dx && coordx >= 0) {
                path_horizontal[counter] = nnum;
                counter  ;
            }
            coord_excess[nnum][0] = coordx;
            coord_excess[nnum][1] = coordy;
            nnum  ;
        }
    }

    int totalNumMatPoint = nnum;
    float coord[totalNumMatPoint][2] = {0.0};

    for (int j = 0; j < 2; j   ) {
        for (int i = 0; i < totalNumMatPoint; i  ) {
            coord[i][j] = coord_excess[i][j];
        }
    }

    int numFam[totalNumMatPoint] = {0};
    int pointFam[totalNumMatPoint] = {0};
    float PDForce[totalNumMatPoint][2] = {0.0};
    float bodyForce[totalNumMatPoint][2] = {0.0};
    float PDforceold[totalNumMatPoint][2] = {0.0};
    float PD_SED_Distortion[totalNumMatPoint][2] = {0.0};
    float surCorrFactorDilatation[totalNumMatPoint][2] = {0.0};
    float surCorrFactorDistorsion[totalNumMatPoint][2] = {0.0};
    float disp[totalNumMatPoint][2] = {0.0};
    float totalDisp[totalNumMatPoint][2] = {0.0};
    float vel[totalNumMatPoint][2] = {0.0};
    
    // AFTER THIS POINT DOWNWARDS, NO OUTPUTS WILL BE GENERATED

    float velhalfold[totalNumMatPoint][2] = {0.0};
    float velhalf[totalNumMatPoint][2] = {0.0};
    float massvec[totalNumMatPoint][2] = {0.0};
    float PD_SED_Dilatation[totalNumMatPoint][2] = {0.0};
    float PD_SED_Dilatation_Fixed[totalNumMatPoint][2] = {0.0};
    int checkTime[timeInterval] = {0};
    float steadyCheck_x[timeInterval] = {0.0};
    float steadyCheck_y[timeInterval] = {0.0};
    float relPositionVector = 0.0;

    for (int j = 0; j < 2; j   ) {
        for (int i = 0; i < totalNumMatPoint; i  ) {
            coord[i][j] = coord_excess[i][j];
            std::cout << coord[i][j] << std::endl;
        }

}

CodePudding user response：

Your code, as is, is not "outputting" anything. I compiled and ran your code and added std::cout statements below and above your comment "AFTER THIS POINT DOWNWARDS, NO OUTPUTS WILL BE GENERATED". This successfully writes to stdout.

If, for example, you wanted to output all the values in the coords array you could do something like this while you are building it:

for (int j = 0; j < 2; j   ) {
    for (int i = 0; i < totalNumMatPoint; i  ) {
        coord[i][j] = coord_excess[i][j];
        std::cout << coord[i][j] << std::endl;
    }
}

CodePudding user response：

I used another PC with a different OS (i.e. Ubuntu) and it is running fine. Not sure what the problem was. Probably something run with my compiler and/or editor on the first computer.