标签: char-pointer

昨天，有人给我看了这个代码：

#include <stdio.h>

int main(void)
{
    unsigned long foo = 506097522914230528;
    for (int i = 0; i < sizeof(unsigned long); ++i)
        printf("%u ", *(((unsigned char *) &foo) + i));
    putchar('\n');

    return 0;
}

这导致：

0 1 2 3 4 5 6 7

我很困惑，主要是for循环中的行。据我所知，似乎&foo是被强制转换为 anunsigned char *然后被i. 我觉得*(((unsigned char *) &foo) + i)是一个更详细的书写方式((unsigned char *) &foo)[i]，但是这使得它看起来像foo，一个unsigned long被索引。如果是这样，为什么？循环的其余部分似乎是典型的打印数组的所有元素，所以一切似乎都表明这是真的。演员unsigned char *阵容让我更加困惑。我试图寻找有关转换的整数类型，以char *对谷歌而言，但我的研究得到了一些后无用的搜索结果停留约铸造int …

我有一个char指针,用于存储字符串.它稍后在程序中使用.

我已经声明并初始化为:

char * p = NULL;

我只是想知道这是不是很好的做法.我正在使用gcc 4.3.3.

我是C++的新手,虽然我有一些编程经验.我已经构建了一个Text类,它使用动态char*作为它的主要成员.在类的定义如下.

#include <iostream>
#include <cstring>
using namespace std;


class Text
{
  public:

    Text();
    Text(const char*); // Type cast char* to Text obj
    Text(const Text&); // Copy constructor
    ~Text();

    // Overloaded operators
    Text& operator=(const Text&);
    Text operator+(const Text&) const; // Concat
    bool operator==(const Text&) const;
    char operator[](const size_t&) const; // Retrieve char at
    friend ostream& operator<<(ostream&, const Text&);

    void get_input(istream&); // User input

  private:
    int length;
    char* str;
};

我遇到的问题是我不知道如何使用operator[],以分配是在通过给定的索引char值.目前的重载运营商 operator[]正在使用返回 …

我是 C 编程新手。我知道char *和char[]数组是不同的。然而，当涉及到函数参数时，您可以扣除char[]to 。char *所以函数声明可能是相同的。

但是我如何知道该函数是否专门需要一个char数组，而不是char *通过查看签名（声明）？

例如，如果我使用库头文件并且函数如下。我如何知道要通过哪一项？

// somelib.h
void foo(char *bar);

因为如果函数正在修改bar参数并且我传递 a char *，它将出现段错误。这是针对 C 的，但是对于 C++ 来说也是一样的吗？

这就是我到目前为止:我传递一个有2个字段的对象:String和Integer,作为参数,我想发送信息来处理它在C部分,这在这一点上并不重要...我得到了抱怨在jstring声明

JNIEXPORT jint JNICALL Java_Tier3_NativeMethods_totalPalletsIn(
            JNIEnv *env, jclass cls, jobject stat) {

jclass staticsitcs = (*env)->GetObjectClass(env, stat);

// Here I try to get it using the ID
jfieldID idDate = (*env)->GetFieldID(env, staticsitcs, "date", "S");

jstring dateString = (jstring)(*env)->GetStringRegion(env, stat, idDate);

// Here converting whatever I get in jstring to char*
char* date = (*env)->GetStringUTFChars(env,dateString,0);

// Getting the 2nd field from the object
jfieldID idNumber = (*env)->GetFieldID(env, staticsitcs, "amount", "I");

jint amount = (*env)->GetDoubleField(env, stat, idNumber);

// Calling C method
jint …

假设我有一个这样的程序:

#include <iostream>
#include <string>
#include <vector>

// Takes values and outputs a string vector.
std::vector<std::string> foo(const int argc, char* args[]) {
    std::vector<std::string> strings;
    for (int i = 0; i < argc; i++)
        strings.push_back(args[i]);
    return strings;
}

int main(int argc, char *args[]) {

    std::vector<std::string> strings = foo(argc, args);

    for (unsigned int i = 0; i < strings.size(); i++)
        std::cout << strings[i] << std::endl;

    return 0;
}

我要尝试将main()函数的char**参数传递给另一个函数或类.(我知道有更好的方法可以实现上述程序的功能,我的问题是将char**参数作为只读方式传递).

问题:

1. 我发现我不能像第一个那样使第二个foo()参数成为const.为什么是这样？char**无法转换为const char**？
2. 我想把这个论点称为"只读".我不知道如何解决这个问题,如果它是一个字符串我会通过const引用传递它,但我不知道如何用指针来解决这个问题？

在尝试使用c ++和OpenGL3 +进行图形编程时,我遇到了一个稍微专门的理解问题,包括char类型,指向它的指针以及潜在的隐式或显式转换到其他char指针类型.我想我已经找到了一个解决方案,但我想通过要求你对此进行双重检查.

当前(2014年10月)OpenGL4.5核心配置文件规范(2.2章命令语法中的表2.2)列出了OpenGL数据类型并明确说明了

GL类型不是C类型.因此,例如,GL类型int在本文档之外被称为GLint,并且不一定等同于C类型int.实现必须精确使用表中指示的位数来表示GL类型.

此表中的GLchar类型被指定为位宽8的类型,用于表示组成字符串的字符.
为了进一步缩小GLchar提供的范围,我们可以看一下GLSL规范(OpenGL着色语言4.25,2014年7月,第3.1章字符集和编译阶段):

用于OpenGL着色语言的源字符集是UTF-8编码方案中的Unicode.

现在,我在任何OpenGL库头中实现它的方式,我关心的是一个简单的

typedef char GLchar;

当然,我刚才引用了"GL类型不是C类型"的说法.

通常,这不会是一个问题,因为typedef仅适用于底层类型可能在将来发生变化的情况.

问题始于用户实现.

通过几个关于OpenGL的教程,我遇到了各种方法将GLSL源代码分配给处理它所需的GLchar数组.(请原谅我没有提供所有链接.目前,我没有这样做的声誉.)

网站open.gl喜欢这样做:

const GLchar* vertexSource =
"#version 150 core\n"
"in vec2 position;"
"void main() {"
"   gl_Position = vec4(position, 0.0, 1.0);"
"}";

或这个:

// Shader macro
#define GLSL(src) "#version 150 core\n" #src

// Vertex shader
const GLchar* vertexShaderSrc = GLSL(
  in vec2 pos;

  void main() {
      gl_Position = vec4(pos, 0.0, 1.0);
  }
);

在lazyfoo.net(第30章加载文本文件着色器)中,源代码从文件(我的首选方法)读取到一个std::string shaderString变量中,然后用于初始化GL字符串:

const GLchar* …

让我们考虑以下代码:

struct Blob {
    double x, y, z;
} blob;

char* s = reinterpret_cast<char*>(&blob);
s[2] = 'A';

假设sizeof(double)为8,此代码是否会触发未定义的行为？

在使用指针算法时offsetof,是否采用了良好定义的行为来获取结构的地址,向其添加成员的偏移量,然后取消引用该地址以获取基础成员？

请考虑以下示例:

#include <stddef.h>
#include <stdio.h>

typedef struct {
    const char* a;
    const char* b;
} A;

int main() {
    A test[3] = {
        {.a = "Hello", .b = "there."},
        {.a = "How are", .b = "you?"},
        {.a = "I\'m", .b = "fine."}};

    for (size_t i = 0; i < 3; ++i) {
        char* ptr = (char*) &test[i];
        ptr += offsetof(A, b);
        printf("%s\n", *(char**)ptr);
    }
}

这应该打印"那里","你呢？" 并且"很好".连续三行,它目前与clang和gcc一起使用,因为你可以在wandbox上验证自己.但是,我不确定这些指针强制转换和算术是否违反某些规则会导致行为变为未定义.

我问一个问题，它并没有得到一个非常明确的答案，但看完后这篇文章，我开始喜欢const char[]到const char*。

我在用三元初始化时遇到了困难。鉴于const bool bar，我试过：

1. const char foo[] = bar ? "lorem" : "ipsum" 这给了我错误：

错误：初始化程序无法确定的大小 foo

2. const char foo[] = bar ? { 'l', 'o', 'r', 'e', 'm', '\0' } : { 'i', 'p', 's', 'u', 'm', '\0' } 这给了我错误：

错误：{令牌前的预期主表达式

有没有办法const char []用三元初始化 a ，还是我必须切换到const char*这里？