在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（char * g）被注释掉，那么* 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

在parttwo()函数中，返回局部变量的地址

return rightSide;

其中rightSide是指向局部变量的指针。

您的编译器似乎通过指向本地变量arrayRight向您发出了一个警告，这可能会使编译器混淆，但结果将是相同的，{{1函数返回后将不再存在。

你在整个代码中都做同样的事情，更糟糕的是，在arrayRight函数中，你返回一个局部变量的地址，它带有它的地址，你不仅要将地址返回到局部变量，但也有一种与函数的返回类型不兼容的类型。

这是您的代码可能存在的许多可能问题之一，但您需要开始修复它以继续解决其他可能的问题。

注意：在编译时启用额外警告并听取它们，除非您确切知道自己在做什么，否则不要试图欺骗编译器。

Answer 2

在secondexp和parttwo的已注释部分中，您return the address of a local variable, which you shouldn't do。

您似乎填补了许多临时大小的辅助阵列。这些问题是它们可能会溢出来处理更大的表达式，并且除非您使用malloc在堆上分配它们，否则无法返回它们，这也意味着您以后必须free它们。

乍一看，要返回的字符串是表达式字符串的子字符串或切片。这意味着这些字符串的数据已经存在。

你可以（安全地）将指针返回到该字符串中。就是这样，例如strchr和strstr。如果您愿意修改原始字符串，也可以在子字符串后放置空终止符'\0'。这是strtok的作用，它的缺点是你丢失了那个地方的信息：如果你的字符串是a*b而你修改为a\0b，你就不会知道哪个运营商。

另一种方法是创建一个结构，该结构将切片存储为字符串中的指针和长度：

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

然后，您可以安全地返回原始字符串的片段，而无需担心额外的内存。

如果您坚持使用strn变体，在大多数情况下也可以使用标准功能。打印切片时，可以通过以printf格式指定字段宽度来执行此操作：

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