струнные Печать указатели в C

Question

Таким образом, по существу, у меня есть два файла:

Файл 1:

// 
// main.c 
// frederickterry 
// 
// Created by Rick Terry on 1/15/15. 
// Copyright (c) 2015 Rick Terry. All rights reserved. 
// 

#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 

int size (char *g) { 
    int ofs = 0; 

    while (*(g+ofs) != '\0') { 
     ++ofs; 
    } 

    return ofs; 
} 

int parse(char *g) { 
    // Setup 
    char binaryConnective; 
    int negated = 0; 

    // Looking for propositions 
    int fmlaLength = size(g); 
    if(fmlaLength == 0) { 
     return 1; 
    } 


    if(fmlaLength == 1) { 
     if(g[0] == 'p') { 
      return 1; 
     } else if (g[0] == 'q') { 
      return 1; 
     } else if (g[0] == 'r') { 
      return 1; 
     } else { 
      return 0; 
     } 
    } 
    // Now looking for negated preposition 

    if(fmlaLength == 2) { 
     char temp[100]; 
     strcpy(temp, g); 
     if(g[0] == '-') { 
      negated = 1; 
      int negatedprop = parse(g+1); 
      if(negatedprop == 1) { 
       return 2; 
      } 
     } 
    } 

    // Checking if Binary Formula 
    char arrayleft[50]; 
    char arrayright[50]; 
    char *left = ""; 
    char *right = ""; 
    int numLeft = 0; 
    int numRight = 0; 
    int bclocation = 0; 
    int binarypresent = 0; 



    if(fmlaLength != 1 && fmlaLength != 2) { 
     if(g[0] == '-') { 
      int negatedBinary = parse(g+1); 
      if(negatedBinary == 1 || negatedBinary == 2 || negatedBinary == 3) { 
       return 2; 
      } else { 
       return 0; 
      } 
     } 
     int i = 0; 
     int l = 0; 
     int p = strlen(g); 
     for(l = 0; l < strlen(g)/2; l++) { 
      if(g[l] == '(' && g[p-l-1] == ')') { 
       i++; 
      } 
     } 


     for(int q = i; q < strlen(g); q++) { 
      if(g[q] == '(') { 
       numLeft++; 
      } else if(g[q] == ')') { 
       numRight++; 
      } 
      arrayleft[q] = g[q]; 

      //printf("%c", arrayleft[i]); 
      //printf("%s", left); 


      if((numRight == numLeft) && (g[q+1] == 'v' || g[q+1] == '>' || g[q+1] == '^')) { 
       arrayleft[q+1] = '\0'; 
       bclocation = q+1; 
       binaryConnective = g[q+1]; 
       binarypresent = 1; 
       //     printf("The binary connecive is: %c\n", binaryConnective); 
       break; 
      } 

     } 
     if(binarypresent == 0) { 
      return 0; 
     } 

     int j = 0; 
     for(int i = bclocation+1; i < strlen(g)-1; i++) { 
      arrayright[j] = g[i]; 
      j++; 
     } 

     arrayright[j] = '\0'; 

     left = &arrayleft[1]; 
     right = &arrayright[0]; 
     //printf("Printed a second time, fmla 1 is: %s", left); 
     int parseleft = parse(left); 
     //  printf("Parse left result: %d\n", parseleft); 
     if(parseleft == 0) { 
      return 0; 
     } 
     int parseright = parse(right); 

     if(parseright == 0) { 
      return 0; 
     } 
     //  printf("Parse right result: %d\n", parseleft); 
     if(negated == 1) { 
      return 2; 
     } else { 
      return 3; 
     } 
    } 

    return 0; 
} 

int type(char *g) { 
    if(parse(g) == 1 ||parse(g) == 2 || parse(g) == 3) { 
     if(parse(g) == 1) { 
      return 1; 
     } 
     /* Literals, Positive and Negative */ 
     if(parse(g) == 2 && size(g) == 2) { 
      return 1; 
     } 
     /* Double Negations */ 
     if(g[0] == '-' && g[1] == '-') { 
      return 4; 
     } 
     /* Alpha & Beta Formulas */ 
     char binaryConnective; 
     int numLeft = 0; 
     int numRight = 0; 
     int bclocation = 0; 
     int binarypresent = 0; 

     int i = 0; 
     if(g[0] == '(') { 
      i++; 
     } 


     if(g[0] == '-') { 
      i++; 
      if(g[1] == '(') { 
       i++; 
      } 
     } 

     for(i; i < strlen(g); ++i) { 
      if(g[i] == '(') { 
       numLeft++; 
      } else if(g[i] == ')') { 
       numRight++; 
      } 

      if(numRight == numLeft) { 
       if(g[i+1] == 'v' || g[i+1] == '>' || g[i+1] == '^') { 
        bclocation = i+1; 
        binaryConnective = g[i+1]; 
        binarypresent = 1; 
        break; 
       } 
      } 
     } 

     /* Connective established */ 
     if(binaryConnective == '^') { 
      if(g[0] == '-') { 
       return 3; 
      } else { 
       return 2; 
      } 
     } else if(binaryConnective == '>') { 
      if(g[0] == '-') { 
       return 2; 
      } else { 
       return 3; 
      } 
     } else if (binaryConnective == 'v') { 
      if(g[0] == '-') { 
       return 2; 
      } else { 
       return 3; 
      } 
     } 
    } 
    return 0; 
} 

char bin(char *g) { 
    char binaryConnective; 
    char arrayLeft[50]; 
    int numLeft = 0; 
    int numRight = 0; 
    int bclocation = 0; 

    int i = 0; 
    if(g[0] == '(') { 
     i++; 
    } 

    if(g[0] == '-') { 
     i++; 
     if(g[1] == '(') { 
      i++; 
     } 
    } 

    for(i; i < strlen(g); ++i) { 
     if(g[i] == '(') { 
      numLeft++; 
     } else if(g[i] == ')') { 
      numRight++; 
     } 
     int j = 0; 
     arrayLeft[j++] = g[i]; 

     if(numRight == numLeft) { 
      if(g[i+1] == 'v' || g[i+1] == '>' || g[i+1] == '^') { 
       arrayLeft[i+1] = '\0'; 
       bclocation = i+1; 
       binaryConnective = g[i+1]; 
       return binaryConnective; 
      } 
     } 
    } 
    return binaryConnective; 
} 

char *partone(char *g) { 
    char binaryConnective; 
    char arrayLeft[50]; 
    char arrayRight[50]; 
    int numLeft = 0; 
    int numRight = 0; 
    int bclocation = 0; 

    int i = 0; 
    if(g[0] == '(') { 
     i++; 
    } 

    if(g[0] == '-') { 
     i++; 
     if(g[1] == '(') { 
      i++; 
     } 
    } 
    int j = 0; 
    for(i; i < strlen(g); ++i) { 
     if(g[i] == '(') { 
      numLeft++; 
     } else if(g[i] == ')') { 
      numRight++; 
     } 
     arrayLeft[j] = g[i]; 

     if(numRight == numLeft) { 
      if(g[i+1] == 'v' || g[i+1] == '>' || g[i+1] == '^') { 
       arrayLeft[j+1] = '\0'; 
       bclocation = i+1; 
       binaryConnective = g[i+1]; 
       break; 
      } 
     } 
     j++; 
    } 
    int m = 0; 
    for(int k = bclocation+1; k < strlen(g)-1; k++) { 
     arrayRight[m] = g[k]; 
     m++; 
    } 

    arrayRight[m] = '\0'; 

    char* leftSide = &arrayLeft[0]; 
    // printf("%s\n", leftSide); 
    // printf("%s\n", rightSide); 
    int k = 0; 
    k++; 
    return leftSide; 
} 

char *parttwo(char *g) { 
    char binaryConnective; 
    char arrayLeft[50]; 
    char arrayRight[50]; 
    int numLeft = 0; 
    int numRight = 0; 
    int bclocation = 0; 

    int i = 0; 
    if(g[0] == '(') { 
     i++; 
    } 

    if(g[0] == '-') { 
     i++; 
     if(g[1] == '(') { 
      i++; 
     } 
    } 
    int j = 0; 
    for(i; i < strlen(g); ++i) { 
     if(g[i] == '(') { 
      numLeft++; 
     } else if(g[i] == ')') { 
      numRight++; 
     } 
     arrayLeft[j] = g[i]; 

     if(numRight == numLeft) { 
      if(g[i+1] == 'v' || g[i+1] == '>' || g[i+1] == '^') { 
       arrayLeft[j+1] = '\0'; 
       bclocation = i+1; 
       binaryConnective = g[i+1]; 
       break; 
      } 
     } 
     j++; 
    } 
    int m = 0; 
    int n = size(g) - 1; 
    if(g[strlen(g)-1] != ')') { 
     n++; 
    } 
    for(int k = bclocation+1; k < n; k++) { 
     arrayRight[m] = g[k]; 
     m++; 
    } 

    arrayRight[m] = '\0'; 

    char* leftSide = &arrayLeft[0]; 
    char* rightSide = &arrayRight[0]; 
    // printf("%s\n", leftSide); 
    // printf("%s\n", rightSide); 

    return rightSide; 
} 

char *firstexp(char *g) { 
    char* left = partone(g); 
    char leftArray[50]; 
    int i = 0; 
    for(i; i < strlen(left); i++) { 
     leftArray[i] = left[i]; 
    } 
    leftArray[i] = '\0'; 
    char binConnective = bin(g); 
    int typeG = type(g); 
    if(typeG == 2) { 
     if(binConnective == '^') { 
      return &leftArray; 
     } else if(binConnective == '>') { 
      return &leftArray; 
     } 
    } else if(typeG == 3) { 
     if(binConnective == 'v') 
      return &leftArray; 
    } 
    char temp[50]; 
    for(int i = 0; i < strlen(leftArray); i++) { 
     temp[i+1] = leftArray[i]; 
    } 
    temp[0] = '-'; 
    char* lefttwo = &temp[0]; 

    if(typeG == 2) { 
     if(binConnective == 'v') { 
      return lefttwo; 
     } 
    } else if(typeG == 3) { 
     if(binConnective == '>' || binConnective == '^') { 
      return lefttwo; 
     } 
    } 

    return "Hello"; 
} 

char *secondexp(char *g) { 
// char binaryConnective = bin(g); 
// char* right = parttwo(g); 
// char rightArray[50]; 
// int i = 0; 
// for(i; i< strlen(right); i++) { 
//  rightArray[i+1] = right[i]; 
// } 
// rightArray[i] = '\0'; 
// int typeG = type(g); 
// if(type(g) == 2) { 
//  if(binaryConnective == '^') { 
//   return &rightArray; 
//  } 
// } else if(type(g) == 3) { 
//  if(binaryConnective == 'v' || binaryConnective == '>') { 
//   return &rightArray; 
//  } 
// } 


     return "Hello"; 
} 

typedef struct tableau tableau; 
\ 

\ 
struct tableau { 

    char *root; 

    tableau *left; 

    tableau *right; 

    tableau *parent; 

    int closedbranch; 

}; 


int closed(tableau *t) { 
    return 0; 
} 

void complete(tableau *t) { 
} 

/*int main(int argc, const char * argv[]) 
{ 
    printf("Hello, World!\n"); 
    printf("%d \n", parse("p^q")); 
    printf("%d \n", type("p^q")); 
    printf("%c \n", bin("p^q")); 
    printf("%s\n", partone("p^q")); 
    printf("%s\n", parttwo("p^q")); 
    printf("%s\n", firstexp("p^q")); 
    printf("Simulation complete"); 
    return 0; 
}*/ 

Файл 2:

#include <stdio.h> 
#include <string.h> /* for all the new-fangled string functions */ 
#include <stdlib.h>  /* malloc, free, rand */ 
#include "yourfile.h" 

int Fsize = 50; 

int main() 

{ /*input a string and check if its a propositional formula */ 
    char *name = malloc(Fsize); 
    printf("Enter a formula:"); 
    scanf("%s", name); 
    int p=parse(name); 
    switch(p) 
    {case(0): printf("not a formula");break; 
     case(1): printf("a proposition");break; 
     case(2): printf("a negated formula");break; 
     case(3): printf("a binary formula");break; 
     default: printf("what the f***!"); 
    } 
    printf("\n"); 
    if (p==3) 
    { 
     printf("the first part is %s and the second part is %s", partone(name), parttwo(name)); 
     printf(" the binary connective is %c \n", bin(name)); 
    } 


    int t =type(name); 
    switch(t) 
    {case(0):printf("I told you, not a formula");break; 
     case(1): printf("A literal");break; 
     case(2): printf("An alpha formula, ");break; 
     case(3): printf("A beta formula, ");break; 
     case(4): printf("Double negation");break; 
     default: printf("SOmewthing's wrong"); 
    } 
    if(t==2) printf("first expansion fmla is %s, second expansion fmla is %s\n", firstexp(name), secondexp(name)); 
    if(t==3) printf("first expansion fmla is %s, second expansion fmla is %s\n", firstexp(name), secondexp(name)); 




    tableau tab; 
    tab.root = name; 
    tab.left=0; 
    tab.parent=0; 
    tab.right=0; 
    tab.closedbranch=0; 


    complete(&tab);/*expand the root node then recursively expand any child nodes */ 
    if (closed(&tab)) printf("%s is not satisfiable", name); 
    else printf("%s is satisfiable", name); 

    return(0); 
} 

Если посмотреть на первый файл, вы» Вы увидите метод, называемый * firstexp (char * g).

Этот метод работает отлично, но только если закомментирован другой метод, называемый * secondexp (char * g).

Если * secondexp (символ * г) закомментирована, то * firstexp работает так:

Enter a formula:((pvq)>-p) 
a binary formula 
the first part is (pvq) and the second part is -p the binary connective is > 
A beta formula, first expansion fmla is -(pvq), second expansion fmla is Hello 
((pvq)>-p) is satisfiableProgram ended with exit code: 0 

в противном случае, если * secondexp не закомментирована, он работает так:

Enter a formula:((pvq)>-p) 
a binary formula 
the first part is (pvq) and the second part is -p the binary connective is > 
A beta formula, first expansion fmla is \240L, second expansion fmla is (- 
((pvq)>-p) is satisfiable. Program ended with exit code: 0 

Как вы можете видеть, выходы полностью разные, несмотря на тот же вход. Может кто-нибудь объяснить, что здесь происходит?

Answer 1

В записях от secondexp и в parttwo, вы return the address of a local variable, which you shouldn't do.

Кажется, что вы заполняете множество вспомогательных массивов ad-hoc. У них есть проблема, что они могут переполняться для больших выражений, а также что вы не можете вернуть их, если вы не разместите их в куче с помощью malloc, что также означает, что вы должны добавить их до free.

На первый взгляд строки, которые вы хотите вернуть, являются подстроками или срезами строки выражения. Это означает, что данные для этих строк уже есть.

Вы можете (безопасно) вернуть указатели в эту строку. Вот что, например, strchr и strstr do.Если вы хотите изменить исходную строку, вы также можете поместить нулевые терминаторы '\0' после подстрок. Это то, что делает strtok, и у него есть тот недостаток, что вы теряете информацию в этом месте: если строка равна a*b, и вы изменяете ее до a\0b, вы не знаете, какой из них был.

Другим способ заключается в создании структуры, которая хранит ломоть как указатель в строку и длина:

struct slice { 
    const char *p; 
    int length; 
}; 

Вы можете безопасно вернуться кусочками исходной строки без необходимости беспокоиться о дополнительной памяти.

Вы также можете использовать стандартные функции в большинстве случаев, если придерживаетесь вариантов strn. При печати ломтика, вы можете сделать это, указав ширину поля в printf форматах:

printf("Second part: '%.*s'\n", s->length, s->p); 

Answer 2

В вашей parttwo() функции вы возвращает адрес локальной переменной

return rightSide; 

rightSide, где есть указатель на локальную переменную.

Похоже, что ваш компилятор дал вам предупреждение об этом, которое вы решили, сделав указатель на локальную variabe arrayRight, что может ввести в заблуждение компилятор, но результат будет таким же, данные в arrayRight больше не будет существовать после того, как функция возвращается.

Вы делаете то же самое во всем своем коде и, что еще хуже, в функции secondexp(), вы возвращаете адрес локальной переменной, принимающей его адрес, вы не только возвращаете адрес в локальную переменную, но также с тип, который несовместим с типом возвращаемой функции.

Это одна из многих вероятных проблем, которые могут возникнуть у вашего кода, но вам нужно начать исправление этого, чтобы продолжить другие возможные проблемы.

Примечание: включить дополнительные предупреждения при компиляции и прослушивать их, не пытайтесь обмануть компилятор, если вы точно не знаете, что делаете.